libvisio-rs 0.2.1

A Rust library for parsing Microsoft Visio files (.vsdx and .vsd) and converting to SVG
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

//! NURBS curve evaluation using De Boor's algorithm.

/// Evaluate a NURBS curve.
///
/// ctrl_pts: list of (x, y, weight) control points
/// knots: knot vector
/// degree: curve degree (typically 3)
/// num_samples: number of output points
///
/// Returns list of (x, y) points along the curve.
pub fn evaluate_nurbs_curve(
    ctrl_pts: &[(f64, f64, f64)],
    knots: &[f64],
    degree: usize,
    num_samples: usize,
) -> Vec<(f64, f64)> {
    let n = ctrl_pts.len();
    if n < 2 {
        return ctrl_pts.iter().map(|p| (p.0, p.1)).collect();
    }

    // Convert to homogeneous weighted coordinates
    let weighted: Vec<[f64; 3]> = ctrl_pts
        .iter()
        .map(|p| [p.0 * p.2, p.1 * p.2, p.2])
        .collect();

    let p = degree;
    let t_min = if p < knots.len() { knots[p] } else { 0.0 };
    let t_max = if n < knots.len() {
        knots[n]
    } else {
        *knots.last().unwrap_or(&1.0)
    };

    if (t_max - t_min).abs() < 1e-10 {
        return vec![
            (ctrl_pts[0].0, ctrl_pts[0].1),
            (ctrl_pts[n - 1].0, ctrl_pts[n - 1].1),
        ];
    }

    let mut result = Vec::with_capacity(num_samples + 1);
    for step in 0..=num_samples {
        let mut t = t_min + (t_max - t_min) * step as f64 / num_samples as f64;
        t = t.max(t_min).min(t_max - 1e-10);

        // Find knot span
        let mut span = p;
        for j in p..n {
            if j + 1 < knots.len() && knots[j + 1] > t {
                span = j;
                break;
            }
            if j == n - 1 {
                span = n - 1;
            }
        }

        // De Boor recursion
        let mut d: Vec<[f64; 3]> = Vec::with_capacity(p + 1);
        for j in 0..=p {
            let idx = (span as isize - p as isize + j as isize) as usize;
            if idx < n {
                d.push(weighted[idx]);
            } else {
                d.push([0.0, 0.0, 1.0]);
            }
        }

        for r in 1..=p {
            for j in (r..=p).rev() {
                let left = (span as isize - p as isize + j as isize) as usize;
                let ki = left + p + 1 - r;
                let alpha = if ki < knots.len() && left < knots.len() {
                    let denom = knots[ki] - knots[left];
                    if denom.abs() > 1e-10 {
                        (t - knots[left]) / denom
                    } else {
                        0.0
                    }
                } else {
                    0.0
                };
                #[allow(clippy::needless_range_loop)]
                for k in 0..3 {
                    d[j][k] = (1.0 - alpha) * d[j - 1][k] + alpha * d[j][k];
                }
            }
        }

        let w = d[p][2];
        if w.abs() > 1e-10 {
            result.push((d[p][0] / w, d[p][1] / w));
        } else if let Some(&last) = result.last() {
            result.push(last);
        }
    }

    result
}