mgart 0.0.2

Machine Generated Art. CLI app for generating algorithmic art
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;

use log::debug;

pub mod buddhabrot;
pub mod debug;
pub mod julia_set;
pub mod util;

use crate::buddhabrot::Buddhabrot;
use crate::debug::ColorMap1dRenderer;
use crate::julia_set::JuliaSet;

#[derive(Deserialize)]
pub struct Algorithm {
  #[serde(flatten)]
  algorithm: AlgorithmInner,
  filename: String,
}

#[derive(Deserialize)]
#[serde(tag = "algorithm")]
#[serde(rename_all = "snake_case")]
pub enum AlgorithmInner {
  JuliaSet(JuliaSet),
  Buddhabrot(Buddhabrot),
  #[serde(rename = "debug.color_map_1d")]
  ColorMap1dRenderer(ColorMap1dRenderer),
}

impl Algorithm {
  /// Creates a new instance of [`Algorithm`] creating a rendering
  /// of a [`JuliaSet`].
  ///
  #[must_use]
  pub fn julia_set(julia_set: JuliaSet, filename: String) -> Self {
    Self {
      algorithm: AlgorithmInner::JuliaSet(julia_set),
      filename,
    }
  }

  /// Creates a new instance of [`Algorithm`] creating a rendering
  /// of a [`Buddhabrot`].
  ///
  #[must_use]
  pub fn buddhabrot(
    buddhabrot: Buddhabrot,
    filename: String,
  ) -> Self {
    Self {
      algorithm: AlgorithmInner::Buddhabrot(buddhabrot),
      filename,
    }
  }

  /// Creates a new instance of [`Algorithm`] creating a debug
  /// rendering of a [`ColorMap1d`][ColorMap1dRenderer].
  ///
  #[must_use]
  pub fn color_map_1d_renderer(
    color_map_1d_renderer: ColorMap1dRenderer,
    filename: String,
  ) -> Self {
    Self {
      algorithm: AlgorithmInner::ColorMap1dRenderer(
        color_map_1d_renderer,
      ),
      filename,
    }
  }

  /// Executes the rendering process for the given [`Algorithm`],
  /// creating a media file containing the generated artwork.
  ///
  /// # Panics
  ///
  /// Panics if the rendering process fails.
  /// Rendering processes fail, because saving the generated image to
  /// disk was unsuccessful or because the provided
  /// [`configuration`](Self) is faulty.
  ///
  pub fn create(self) {
    match self.algorithm {
      AlgorithmInner::JuliaSet(j) => {
        debug!("generating julia:\n{}", j);
        j.creator().create().save_as_image(&self.filename);
      }
      AlgorithmInner::Buddhabrot(b) => {
        debug!("generating buddhabrot: \n{}", b);
        b.creator().create().save_as_image(&self.filename);
      }
      AlgorithmInner::ColorMap1dRenderer(c) => {
        debug!("generating 1d color map:\n{}", c);
        c.creator().create().save_as_image(&self.filename);
      }
    }
  }
}

#[derive(Deserialize)]
pub struct Algorithms(Vec<Algorithm>);

impl Algorithms {
  /// Creates a new instance of [`Algorithms`].
  ///
  #[must_use]
  pub fn new(algorithms: Vec<Algorithm>) -> Self {
    Self(algorithms)
  }

  /// Executes each [`Algorithm`] successively.
  ///
  /// Multi-threading is implemented inside the rendering process of
  /// each [`Algorithm`].
  ///
  /// # Panics
  ///
  /// If one of the provided algorithms fails.
  ///
  pub fn create(self) {
    for cmd in self.0 {
      cmd.create();
    }
  }
}