dioxuscut-paths 0.1.3

SVG path parsing, metrics, and stroke evolution animations for Dioxuscut
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
148
149
150
151
152
153
154
155
156

//! Point calculation at specific distance along an SVG path.

use crate::parser::parse_path;
use crate::types::{Instruction, Point};

/// Returns the `(x, y)` [`Point`] at a specific `distance` in pixels along an SVG path.
pub fn get_point_at_length(path: &str, distance: f64) -> Point {
    let instructions = match parse_path(path) {
        Ok(insts) => insts,
        Err(_) => return Point::new(0.0, 0.0),
    };

    let target_dist = distance.max(0.0);
    let mut accumulated_dist = 0.0;

    let mut current_x = 0.0;
    let mut current_y = 0.0;
    let mut start_x = 0.0;
    let mut start_y = 0.0;

    for inst in &instructions {
        match inst {
            Instruction::MoveTo { x, y } => {
                current_x = *x;
                current_y = *y;
                start_x = *x;
                start_y = *y;
            }
            Instruction::LineTo { x, y } => {
                let dx = x - current_x;
                let dy = y - current_y;
                let seg_len = (dx * dx + dy * dy).sqrt();

                if accumulated_dist + seg_len >= target_dist {
                    let remaining = target_dist - accumulated_dist;
                    let ratio = if seg_len > 0.0 {
                        remaining / seg_len
                    } else {
                        0.0
                    };
                    return Point::new(current_x + dx * ratio, current_y + dy * ratio);
                }

                accumulated_dist += seg_len;
                current_x = *x;
                current_y = *y;
            }
            Instruction::ClosePath => {
                let dx = start_x - current_x;
                let dy = start_y - current_y;
                let seg_len = (dx * dx + dy * dy).sqrt();

                if accumulated_dist + seg_len >= target_dist {
                    let remaining = target_dist - accumulated_dist;
                    let ratio = if seg_len > 0.0 {
                        remaining / seg_len
                    } else {
                        0.0
                    };
                    return Point::new(current_x + dx * ratio, current_y + dy * ratio);
                }

                accumulated_dist += seg_len;
                current_x = start_x;
                current_y = start_y;
            }
            Instruction::CubicCurveTo {
                x1,
                y1,
                x2,
                y2,
                x,
                y,
            } => {
                let steps = 16;
                let mut prev_x = current_x;
                let mut prev_y = current_y;

                for i in 1..=steps {
                    let t = i as f64 / steps as f64;
                    let mt = 1.0 - t;

                    let px = mt * mt * mt * current_x
                        + 3.0 * mt * mt * t * x1
                        + 3.0 * mt * t * t * x2
                        + t * t * t * x;

                    let py = mt * mt * mt * current_y
                        + 3.0 * mt * mt * t * y1
                        + 3.0 * mt * t * t * y2
                        + t * t * t * y;

                    let dx = px - prev_x;
                    let dy = py - prev_y;
                    let step_len = (dx * dx + dy * dy).sqrt();

                    if accumulated_dist + step_len >= target_dist {
                        return Point::new(px, py);
                    }

                    accumulated_dist += step_len;
                    prev_x = px;
                    prev_y = py;
                }

                current_x = *x;
                current_y = *y;
            }
            Instruction::QuadCurveTo { x1, y1, x, y } => {
                let steps = 16;
                let mut prev_x = current_x;
                let mut prev_y = current_y;

                for i in 1..=steps {
                    let t = i as f64 / steps as f64;
                    let mt = 1.0 - t;

                    let px = mt * mt * current_x + 2.0 * mt * t * x1 + t * t * x;
                    let py = mt * mt * current_y + 2.0 * mt * t * y1 + t * t * y;

                    let dx = px - prev_x;
                    let dy = py - prev_y;
                    let step_len = (dx * dx + dy * dy).sqrt();

                    if accumulated_dist + step_len >= target_dist {
                        return Point::new(px, py);
                    }

                    accumulated_dist += step_len;
                    prev_x = px;
                    prev_y = py;
                }

                current_x = *x;
                current_y = *y;
            }
        }
    }

    Point::new(current_x, current_y)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_point_at_length_line() {
        let path = "M 0 0 L 100 0";
        let pt_mid = get_point_at_length(path, 50.0);
        assert_eq!(pt_mid, Point::new(50.0, 0.0));

        let pt_end = get_point_at_length(path, 100.0);
        assert_eq!(pt_end, Point::new(100.0, 0.0));
    }
}