circles-sketch 0.2.1

Generate interactive Fourier epicycle animations from contours, text, or SVG files
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

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct ThresholdStep {
    pub start: usize,
    pub step: usize,
}

/// Harmonic step schedule: thresholds with increments, plus a final increment.
///
/// For example, thresholds `[(10, 1), (20, 5), (100, 10)]` with `max_harmonic: 100`
/// means: below 10 step by 1, below 20 step by 5, below 100 step by 10, else step by 100.
#[derive(Serialize, Deserialize)]
pub struct HarmonicSteps {
    pub thresholds: Vec<ThresholdStep>,
    pub max_harmonic: usize,
}

impl Default for HarmonicSteps {
    fn default() -> Self {
        Self {
            thresholds: vec![
                ThresholdStep { start: 10, step: 1 },
                ThresholdStep { start: 20, step: 5 },
                ThresholdStep {
                    start: 100,
                    step: 10,
                },
            ],
            max_harmonic: 100,
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct OnceEvery {
    pub modulo: usize,
    pub remainders: Vec<usize>,
}

impl OnceEvery {
    pub fn validate(&self, field: &str) -> Result<(), String> {
        if self.modulo == 0 {
            return Err(format!("{field}: modulo must be > 0"));
        }
        for &r in &self.remainders {
            if r >= self.modulo {
                return Err(format!(
                    "{field}: remainder {r} must be < modulo {}",
                    self.modulo
                ));
            }
        }
        Ok(())
    }
}

#[derive(Serialize, Deserialize)]
pub enum WhenToShow {
    Always,
    Never,
    OnceEvery(OnceEvery),
}

#[derive(Serialize, Deserialize)]
pub struct EmbedOptions {
    pub speed: f64,
    pub steps: HarmonicSteps,
    pub show_contour: WhenToShow,
    pub show_point: bool,
    pub show_trace: WhenToShow,
    pub trace_length: f64,
    pub opacity: f64,
    pub show_nh: bool,
    pub trace_width: f64,
    pub contour_width: f64,
    pub show_fourier_circles: WhenToShow,
    #[serde(default = "default_trace_colors")]
    pub trace_colors: Vec<String>,
}

fn default_trace_colors() -> Vec<String> {
    vec![
        "red".into(),
        "lime".into(),
        "dodgerblue".into(),
        "gold".into(),
        "hotpink".into(),
        "cyan".into(),
        "orange".into(),
    ]
}

impl EmbedOptions {
    pub fn validate(&self) -> Result<(), String> {
        if let WhenToShow::OnceEvery(e) = &self.show_contour {
            e.validate("show_contour")?;
        }
        if let WhenToShow::OnceEvery(e) = &self.show_trace {
            e.validate("show_trace")?;
        }
        if let WhenToShow::OnceEvery(e) = &self.show_fourier_circles {
            e.validate("show_fourier_circles")?;
        }
        Ok(())
    }
}

impl Default for EmbedOptions {
    fn default() -> Self {
        Self {
            speed: 3.0,
            steps: HarmonicSteps::default(),
            show_contour: WhenToShow::Never,
            show_point: true,
            show_trace: WhenToShow::Always,
            trace_length: 0.5,
            opacity: 0.5,
            show_nh: true,
            trace_width: 1.0,
            contour_width: 1.0,
            show_fourier_circles: WhenToShow::Always,
            trace_colors: default_trace_colors(),
        }
    }
}