intvg 0.1.7

lib/tool in Rust to load/save/render tvg file, parse from svg file by usvg
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147


use crate::tinyvg::*;
use std::{error::Error, io};
use usvg::tiny_skia_path as skia;

pub trait Convert { fn from_usvg(svgd: &[u8]) ->
    Result<Self, Box<dyn Error>> where Self: std::marker::Sized;
}

impl<R: io::Read, W: io::Write> Convert for TinyVG<R, W> {
    fn from_usvg(svgd: &[u8]) -> Result<Self, Box<dyn Error>> {
        let mut usvg_opts = usvg::Options::default();
        usvg_opts.fontdb_mut().load_system_fonts();
        let tree = usvg::Tree::from_data(svgd, &usvg_opts)?;    //&std::fs::read(&path)?,

        //Ok(Self::from_usvg(&tree)) }
        //fn from_usvg(tree: &usvg::Tree) -> Self {

        let mut tvg = Self::new();
        tvg.header.width  = tree.size().width() .round() as _;
        tvg.header.height = tree.size().height().round() as _;

        let coordinate_limit = u32::max(tvg.header.width, tvg.header.height);
        //let range_bits = match tvg.header.coordinate_range { CoordinateRange::Default => 16,
        //    CoordinateRange::Reduced => 8, CoordinateRange::Enhanced => 32,
        //} - 1; // coordinate_range/write_default isn't changed from default
        let (range_bits, mut scale_bits) = (16 - 1, 0);

        while scale_bits < range_bits && (coordinate_limit << (scale_bits + 1)) <
            (1 << range_bits) { scale_bits += 1; }  tvg.header.scale = scale_bits;
        // XXX: still need a traversely check CoordinateRange by a null writer?

        convert_nodes(&mut tvg, tree.root(), &usvg::Transform::identity());
        println!("{:?}, {} colors, {} cmds/paths", &tvg.header,
            tvg.color_table.len(), tvg.commands.len());     Ok(tvg)
    }
}

fn convert_nodes<R: io::Read, W: io::Write>(tvg: &mut TinyVG<R, W>,
    parent: &usvg::Group, trfm: &usvg::Transform) {
    for child in parent.children() { match child {
        usvg::Node::Group(group) =>     // XXX: trfm is needed on rendering only
            convert_nodes(tvg, group, &trfm.pre_concat(group.transform())),

        usvg::Node::Path(path) => if path.is_visible() {
            let (coll, mut lwidth) = (convert_path(path.data(), trfm), 0.0);

            let fill = path  .fill().and_then(|fill|
                convert_paint(tvg, fill.paint(), fill.opacity(), trfm));
            let line = path.stroke().and_then(|line| {
                lwidth = line.width().get();    // XXX: need to apply transform?
                convert_paint(tvg, line.paint(), line.opacity(), trfm) });

            //match path.paint_order() {} // XXX:
            let cmd = match (fill, line) {
                (Some(fill), None) => Command::FillPath(FillCMD { fill, coll }),
                (None, Some(line)) => Command::DrawPath(DrawCMD { line, lwidth, coll }),
                (Some(fill), Some(line)) =>
                    Command::OutlinePath(fill, DrawCMD { line, lwidth, coll }),

                _ => { eprintln!("Neither fill nor line"); continue }
            };  tvg.commands.push(cmd);
        }

        usvg::Node::Image(img) => if img.is_visible() {
            match img.kind() {            usvg::ImageKind::JPEG(_) |
                usvg::ImageKind::PNG(_) | usvg::ImageKind::GIF(_) =>
                    eprintln!("TinyVG can't support raster images"),
                usvg::ImageKind::SVG(svg) => convert_nodes(tvg, svg.root(), trfm),
            }
        }

        usvg::Node::Text(text) => { let group = text.flattened();
            convert_nodes(tvg, group, &trfm.pre_concat(group.transform()));
        }
    } }
}

fn convert_path(path: &skia::Path, trfm: &usvg::Transform) -> Vec<Segment> {
    impl From<skia::Point> for Point {  //unsafe { std::mem::transmute(pt) }
        fn from(pt: skia::Point) -> Self { Self { x: pt.x, y: pt.y } }
    }

    let (mut coll, mut cmds) = (vec![], vec![]);
    let  mut start = Point { x: 0.0, y: 0.0 };
    let tpath = if trfm.is_identity() { None
    } else { path.clone().transform(*trfm) };

    for seg in tpath.as_ref().unwrap_or(path).segments() {
        let instr = match seg {
            skia::PathSegment::MoveTo(pt) => { //trfm.map_point(&mut pt);
                if !cmds.is_empty() { coll.push(Segment { start, cmds }); cmds = vec![]; }
                start = pt.into();  continue
            }
            skia::PathSegment::LineTo(pt) => { //trfm.map_point(&mut pt);
                SegInstr::Line { end: pt.into() }
            }
            skia::PathSegment::QuadTo(ctrl, end) => {
                //trfm.map_point(&mut ctrl);  trfm.map_point(&mut end);
                SegInstr::QuadBezier { ctrl: ctrl.into(), end: end.into() }
            }
            skia::PathSegment::CubicTo(ctrl0, ctrl1, end) => {
                //trfm.map_point(&mut ctrl0);
                //trfm.map_point(&mut ctrl1);   trfm.map_point(&mut end);
                SegInstr::CubicBezier { ctrl: (ctrl0.into(), ctrl1.into()), end: end.into() }
            }

            skia::PathSegment::Close => SegInstr::ClosePath,
        };  cmds.push(SegmentCommand { instr, lwidth: None });
    }   if !cmds.is_empty() { coll.push(Segment { start, cmds }); }     coll
}

fn convert_paint<R: io::Read, W: io::Write>(tvg: &mut TinyVG<R, W>,
    paint: &usvg::Paint, opacity: usvg::Opacity, _trfm: &usvg::Transform) -> Option<Style> {
    let get_color = |stop: &usvg::Stop| {
        let color = stop.color();
        RGBA8888 { r: color.red, g: color.green, b: color.blue,
                   a: (stop.opacity() * opacity).to_u8() }
    };

    impl From<(f32, f32)> for Point {   // unsafe { std::mem::transmute(pt) }
        fn from(pt: (f32, f32)) -> Self { Self { x: pt.0, y: pt.1 } }
    }

    match paint { usvg::Paint::Pattern(_) => {  // trfm should be applied here
            eprintln!("Not support pattern painting"); None },
        usvg::Paint::Color(color) => {
            Some(Style::FlatColor(tvg.push_color(RGBA8888 { r: color.red,
                g: color.green, b: color.blue, a: opacity.to_u8() })))
        }
        usvg::Paint::LinearGradient(grad) => {
            let p0 = (grad.x1(), grad.y1()).into();
            let p1 = (grad.x2(), grad.y2()).into();
            let c0 = tvg.push_color(get_color(&grad.stops()[0]));
            let c1 = tvg.push_color(get_color(&grad.stops()[1]));
            Some(Style::LinearGradient { points: (p0, p1), cindex: (c0, c1) })
        }
        usvg::Paint::RadialGradient(grad) => {
            let p0 = (grad.fx(), grad.fy()).into(); // focus/start, center/end
            let p1 = (grad.cx(), grad.cy() + grad.r().get()).into();
            let c0 = tvg.push_color(get_color(&grad.stops()[0]));
            let c1 = tvg.push_color(get_color(&grad.stops()[1]));
            Some(Style::RadialGradient { points: (p0, p1), cindex: (c0, c1) })
        }
    }
}