circles-sketch 0.4.0

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
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

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct HarmonicRange {
    pub from: usize,
    pub step: usize,
    pub to: usize,
    pub speed: f64,
}

#[derive(Serialize, Deserialize)]
pub struct HarmonicSteps {
    pub ranges: Vec<HarmonicRange>,
}

impl HarmonicSteps {
    pub fn validate(&self) -> Result<(), String> {
        for (i, r) in self.ranges.iter().enumerate() {
            if r.to <= r.from {
                return Err(format!(
                    "steps.ranges[{}]: to ({}) must be > from ({})",
                    i, r.to, r.from
                ));
            }
            if i > 0 && r.from < self.ranges[i - 1].to {
                return Err(format!(
                    "steps.ranges[{}]: from ({}) must be >= previous to ({})",
                    i,
                    r.from,
                    self.ranges[i - 1].to
                ));
            }
        }
        Ok(())
    }
}

impl Default for HarmonicSteps {
    fn default() -> Self {
        Self {
            ranges: vec![
                HarmonicRange {
                    from: 1,
                    step: 1,
                    to: 10,
                    speed: 3.0,
                },
                HarmonicRange {
                    from: 10,
                    step: 5,
                    to: 100,
                    speed: 3.0,
                },
            ],
        }
    }
}

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

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

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

#[derive(Serialize, Deserialize)]
pub struct EmbedOptions {
    pub max_harmonics: usize,
    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>,
    #[serde(default)]
    pub flip_y: bool,
}

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> {
        self.steps.validate()?;
        if let WhenToShow::Congruence(e) = &self.show_contour {
            e.validate("show_contour")?;
        }
        if let WhenToShow::Congruence(e) = &self.show_trace {
            e.validate("show_trace")?;
        }
        if let WhenToShow::Congruence(e) = &self.show_fourier_circles {
            e.validate("show_fourier_circles")?;
        }
        Ok(())
    }
}

impl Default for EmbedOptions {
    fn default() -> Self {
        Self {
            max_harmonics: 500,
            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: 2.0,
            contour_width: 1.0,
            show_fourier_circles: WhenToShow::Always,
            trace_colors: default_trace_colors(),
            flip_y: false,
        }
    }
}