Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-svg

Source of release 0.9.2

0.9.2 / src / svg / convert_marker.lucb

#==============================================================================================
#
#   svg/convert_marker - Markers and paint order
#
#   DESCRIPTION:
#       marker-start, marker-mid and marker-end place a copy of a marker's content at
#       the first vertex of a shape's path, at every vertex in between, and at the last.
#       Each copy is translated to its vertex, turned by the marker's orient (an angle,
#       or along the path with `auto`, bisecting the angle at a corner, the start
#       reversed with auto-start-reverse), scaled by the stroke width (markerUnits
#       strokeWidth) or not, fitted by the marker's viewBox, offset by refX and refY,
#       and clipped to the marker's box unless its overflow is visible. Inside a marker,
#       context-fill and context-stroke are the marked shape's paints. paint-order puts
#       the markers before, between or after the fill and stroke. As resvg's usvg does.
#
#==============================================================================================

## A segment of a path, for walking its vertices: a move, line or close to `p`, or a
## cubic through `p1` and `p2` to `p`.
struct Segment:
    var verb: Verb = Verb.move
    var p1: Point = Point()
    var p2: Point = Point()
    var p: Point = Point()

## What paint-order says: the three paints in order, 0 fill, 1 stroke, 2 markers.
func paint_order(text: str) -> u8[3]:
    var order: u8[3] = [0, 1, 2]
    var scanner = Scanner(data = text.bytes)
    var count: usize = 0
    var seen: u8[3] = [0, 0, 0]
    while count < 3:
        scanner.skip_spaces()
        let word = scanner.identifier()
        if word.length == 0:
            break
        var kind: u8 = 3
        if word == "fill":
            kind = 0
        elif word == "stroke":
            kind = 1
        elif word == "markers":
            kind = 2
        elif word == "normal" and count == 0:
            return order
        if kind == 3 or seen[kind] != 0:
            return [0, 1, 2]
        seen[kind] = 1
        order[count] = kind
        count += 1
    scanner.skip_spaces()
    if count == 0 or not scanner.at_end():
        return [0, 1, 2]
    # The paints not named follow in their usual order.
    for kind: u8 in 0..<3:
        if seen[kind] == 0 and count < 3:
            order[count] = kind
            count += 1
    return order

extend Converter:
    ## Append shape item `item` to `parent` with its markers, in paint order.
    func shape_with_markers(node: u32, item: Item, state: const State*, parent: u32) -> !:
        let order = paint_order(self.find(node, Attr.paint_order) else "normal")
        var markers: u32? = none
        let visible = (self.find(node, Attr.visibility) else "visible") == "visible"
        if not state.clip_child and visible:
            markers = try self.markers(node, &item, state)
        let group = markers else 0
        if group == 0:
            _ = try self.picture.append(parent, item)
            return
        if order[0] == 2:
            self.picture.attach(parent, group)
            _ = try self.picture.append(parent, item)
        elif order[1] == 2:
            try self.single_paint(item, order[0], parent)
            self.picture.attach(parent, group)
            try self.single_paint(item, order[2], parent)
        else:
            _ = try self.picture.append(parent, item)
            self.picture.attach(parent, group)

    ## Append `item` with only its fill (`kind` 0) or only its stroke (1), if it has it.
    func single_paint(item: Item, kind: u8, parent: u32) -> !:
        var copy = item
        if kind == 0:
            if item.fill == none:
                return
            copy.stroke = none
        else:
            if item.stroke == none:
                return
            copy.fill = none
        _ = try self.picture.append(parent, copy)

    ## The group of markers shape `node` (as `item`) carries, detached, or none.
    func markers(node: u32, item: const Item*, state: const State*) -> u32?!:
        let names: Attr[3] = [Attr.marker_start, Attr.marker_mid, Attr.marker_end]
        var any = false
        for name in names:
            if self.marker_node(node, name) != none:
                any = true
        if not any:
            return none
        let bounds = self.picture.paths.items[item.path].bounds()
        let group = try self.picture.add_item(Item(context = true, context_box = bounds))
        var marker_state = *state
        marker_state.context_fill = none
        marker_state.context_stroke = none
        if let fill = item.fill:
            var brush = fill.brush
            brush.context = true
            marker_state.context_fill = brush
        if let stroke = item.stroke:
            var brush = stroke.brush
            brush.context = true
            marker_state.context_stroke = brush
        var segments = List[Segment]()
        defer segments.release()
        try path_segments(&self.picture.paths.items[item.path], &segments)
        for kind in 0..<(usize)3:
            let marker = self.marker_node(node, names[kind]) else continue
            if self.entered(marker):
                continue
            try self.place_markers(node, marker, kind, segments.view(), &marker_state, group)
        if self.picture.items.items[group].first == 0:
            return none
        return group

    ## The marker element a marker property of `node` names, if it names one.
    func marker_node(node: u32, name: Attr) -> u32?:
        let text = self.find(node, name) else return none
        let id = func_iri(text) else return none
        let marker = self.tree.element_by_id(id) else return none
        if self.tree.tag(marker) != Tag.marker:
            return none
        return marker

    ## Place copies of `marker` at the vertices `kind` (0 start, 1 mid, 2 end) selects.
    func place_markers(shape: u32, marker: u32, kind: usize, segments: const Segment[], state: const State*, group: u32) -> !:
        if segments.length == 0:
            return
        var stroke_scale = 1.0
        if strings.trim(self.attribute(marker, Attr.marker_units) else "") != "userSpaceOnUse":
            stroke_scale = self.found_length(shape, Attr.stroke_width, state, 1.0)
            if not (stroke_scale > 0.0):
                return
        let zero = Length()
        let three = Length(number = 3.0)
        let r = Rect(x = self.user_length(marker, Attr.ref_x, state, zero), y = self.user_length(marker, Attr.ref_y, state, zero),
                     w = self.user_length(marker, Attr.marker_width, state, three), h = self.user_length(marker, Attr.marker_height, state, three))
        if not (r.w > 0.0) or not (r.h > 0.0):
            return
        let view = parse_view_box(self.attribute(marker, Attr.view_box) else "")
        var aspect = AspectRatio()
        if let text = self.attribute(marker, Attr.preserve_aspect_ratio):
            aspect = parse_aspect_ratio(text) else AspectRatio()
        var clip: usize = 0
        let overflow = strings.trim(self.attribute(marker, Attr.overflow) else "hidden")
        if overflow == "hidden" or overflow == "scroll":
            let box = view else Rect(w = r.w, h = r.h)
            clip = try self.rect_clip(box)
        let orient = strings.trim(self.attribute(marker, Attr.orient) else "")
        let last = segments.length - 1
        for index in 0..<segments.length:
            var chosen = false
            var at = Point()
            let segment = segments[index]
            if kind == 0:
                chosen = index == 0 and segment.verb == Verb.move
                at = segment.p
            elif kind == 1:
                chosen = index > 0 and index < last and segment.verb != Verb.close
                at = segment.p
            else:
                chosen = index == last and segment.verb != Verb.move
                at = subpath_start(segments, index) if segment.verb == Verb.close else segment.p
            if not chosen:
                continue
            var angle = 0.0
            if orient == "auto" or orient == "auto-start-reverse":
                angle = vertex_angle(segments, index)
                if orient == "auto-start-reverse" and index == 0:
                    angle = math.mod(angle + 180.0, 360.0)
            else:
                angle = parse_angle(orient) else 0.0
            var ts = Matrix(e = at.x, f = at.y)
            if angle != 0.0:
                ts = multiply(ts, rotation_matrix(angle))
            if let box = view:
                let fit = view_box_transform(box, aspect, r.w * stroke_scale, r.h * stroke_scale)
                ts = multiply(ts, Matrix(a = math.hypot(fit.a, fit.b), d = math.hypot(fit.c, fit.d)))
            else:
                ts = multiply(ts, Matrix(a = stroke_scale, d = stroke_scale))
            ts = multiply(ts, Matrix(e = -r.x, f = -r.y))
            let copy = try self.picture.add_item(Item(transform = ts, clip = clip))
            try self.active.push(marker)
            try self.children(marker, state, copy)
            self.active.used -= 1
            if self.picture.items.items[copy].first != 0:
                self.picture.attach(group, copy)

    ## A clip path of one rectangle; its index + 1.
    func rect_clip(rect: Rect) -> usize!:
        let root = try self.picture.add_item(Item())
        var path = Path()
        errdefer path.release()
        try path.rect(rect.x, rect.y, rect.w, rect.h)
        let index = self.picture.paths.used
        try self.picture.paths.push(path)
        _ = try self.picture.append(root, Item(kind = ItemKind.shape, path = index, fill = FillPaint()))
        try self.picture.clips.push(ClipServer(root = root))
        return self.picture.clips.used

## `path` as a list of segments.
func path_segments(path: const Path*, out: List[Segment]*) -> !:
    var at: usize = 0
    var start = Point()
    for verb in path.verbs.view():
        match verb:
            .move:
                start = path.points.items[at]
                try out.push(Segment(verb = Verb.move, p = start))
                at += 1
            .line:
                try out.push(Segment(verb = Verb.line, p = path.points.items[at]))
                at += 1
            .cubic:
                try out.push(Segment(verb = Verb.cubic, p1 = path.points.items[at], p2 = path.points.items[at + 1], p = path.points.items[at + 2]))
                at += 3
            .close:
                try out.push(Segment(verb = Verb.close, p = start))

## Where the subpath containing segment `index` began.
func subpath_start(segments: const Segment[], index: usize) -> Point:
    var at = index
    while at > 0:
        at -= 1
        if segments[at].verb == Verb.move:
            return segments[at].p
    return Point()

## The vertex before segment `index`.
func previous_vertex(segments: const Segment[], index: usize) -> Point:
    let segment = segments[index - 1]
    if segment.verb == Verb.close:
        return subpath_start(segments, index)
    return segment.p

func same_point(a: Point, b: Point) -> bool:
    return math.abs(a.x - b.x) < 1e-6 and math.abs(a.y - b.y) < 1e-6

## The direction, in degrees, a marker at segment `index` faces with orient auto.
func vertex_angle(segments: const Segment[], index: usize) -> f64:
    let last = segments.length - 1
    if index == 0:
        if segments.length < 2:
            return 0.0
        let first = segments[0]
        let next = segments[1]
        if first.verb != Verb.move:
            return 0.0
        if next.verb == Verb.line:
            return line_angle(first.p, next.p)
        if next.verb == Verb.cubic:
            return line_angle(first.p, next.p) if same_point(first.p, next.p1) else line_angle(first.p, next.p1)
        return 0.0
    if index == last:
        let before = segments[index - 1]
        let here = segments[index]
        match here.verb:
            .move:
                return 0.0
            .line:
                return line_angle(previous_vertex(segments, index), here.p)
            .cubic:
                return line_angle(here.p1, here.p) if same_point(here.p2, here.p) else line_angle(here.p2, here.p)
            .close:
                let next = subpath_start(segments, index)
                if before.verb == Verb.line:
                    return line_angle(before.p, next)
                if before.verb == Verb.cubic:
                    return curves_angle(previous_vertex(segments, index), before.p2, before.p, next, next)
                return 0.0
    let here = segments[index]
    let next = segments[index + 1]
    if here.verb == Verb.move:
        if next.verb == Verb.line:
            return line_angle(here.p, next.p)
        if next.verb == Verb.cubic:
            return line_angle(here.p, next.p1)
        return 0.0
    if here.verb == Verb.close:
        return 0.0
    if next.verb == Verb.move:
        if here.verb == Verb.cubic and not same_point(here.p, here.p2):
            return line_angle(here.p2, here.p)
        return line_angle(previous_vertex(segments, index), here.p)
    if next.verb == Verb.close:
        let prev = previous_vertex(segments, index)
        let start = subpath_start(segments, index)
        if here.verb == Verb.line:
            return bisector_angle(prev, here.p, here.p, start)
        return line_angle(prev, start)
    let prev = previous_vertex(segments, index)
    if here.verb == Verb.line and next.verb == Verb.line:
        return bisector_angle(prev, here.p, here.p, next.p)
    if here.verb == Verb.cubic and next.verb == Verb.cubic:
        return curves_angle(prev, here.p2, here.p, next.p1, next.p)
    if here.verb == Verb.line:
        return curves_angle(prev, prev, here.p, next.p1, next.p)
    return curves_angle(prev, here.p2, here.p, next.p, next.p)

func line_angle(a: Point, b: Point) -> f64:
    return bisector_angle(a, b, a, b)

## The angle at `p` between curves arriving from control `c1` (vertex `before`) and
## leaving towards control `c2` (vertex `after`), falling back to the vertices where a
## control point sits on `p`.
func curves_angle(before: Point, c1: Point, p: Point, c2: Point, after: Point) -> f64:
    if same_point(c1, p):
        return bisector_angle(before, p, p, c2)
    if same_point(p, c2):
        return bisector_angle(c1, p, p, after)
    return bisector_angle(c1, p, p, c2)

## The angle halfway between the direction a1→a2 and the direction b1→b2, in degrees.
func bisector_angle(a1: Point, a2: Point, b1: Point, b2: Point) -> f64:
    let incoming = direction_angle(a2.x - a1.x, a2.y - a1.y)
    let outgoing = direction_angle(b2.x - b1.x, b2.y - b1.y)
    let half = (outgoing - incoming) * 0.5
    var angle = incoming + half
    if math.abs(half) > math.pi * 0.5:
        angle -= math.pi
    return normalized_angle(angle) * 180.0 / math.pi

func direction_angle(x: f64, y: f64) -> f64:
    let radians = math.atan2(y, x)
    return 0.0 if math.is_nan(radians) else normalized_angle(radians)

func normalized_angle(radians: f64) -> f64:
    let value = math.mod(radians, math.tau)
    return value + math.tau if value < 0.0 else value