The best part of generative art is accumulating techniques and improving your creative coding skills. You explore your imagination and can combine different ideas and techniques over time once you have &quot;absorbed&quot; them in our playbook. IF you know N techniques, one more technique is now giving you <code>N*(N+1)</code> possibilities of outcomes. They can all be crossed over and combined together to produce results. It&#39;s exponential.
Here is the combination of shape packing, applied to triangle polygon, filled with one of my oldest &quot;fill&quot; algorithm that works by rotating around randomly sampled points.

combination of shape packing, applied to polygon, filled with one of my oldest fill algorithm that works by rotating around randomly sampled points

triangle noise spiral

A variant of <a href="/plots/203">plot#203</a>.
<blockquote>
I like randomness a lot. Exploring the beauty of noise is also recreating Nature&#39;s pattern and trying to put back some order in that randomness.
</blockquote>

I like randomness a lot. Exploring the beauty of noise is also recreating Nature's pattern and trying to put back some order in that randomness.

Bloody circles & ordered noise

As you may notice, I like randomness a lot. Exploring the beauty of noise is also recreating Nature&#39;s pattern and trying to put back some order in that randomness.
This creation is an unusual version of &quot;circle packing&quot; that instead of a pure random distribution will run a few times to actually try to find the biggest circle to place. This makes the distribution less random and way more ordered. However, the fact there is a &quot;a few times&quot; maximum tries gives some room for some randomness and not &quot;pure order&quot;.
The algorithm at stake is relatively simple, I will have to improve it in future to parallelize the computation.
<pre><code class="language-rust">fn packing(
 seed: f64,
 iterations: usize,
 desired_count: usize,
 optimize_size: usize, // &lt;--- number of retries to optimize the size
 pad: f64,
 container: &amp;VCircle,
 min_scale: f64,
 max_scale: f64,
) -&gt; Vec&lt;VCircle&gt; {
 let mut circles = Vec::new();
 let mut tries = Vec::new();
 let mut rng = rng_from_seed(seed);
 let x1 = container.x - container.r;
 let y1 = container.y - container.r;
 let x2 = container.x + container.r;
 let y2 = container.y + container.r;
 let max_scale = max_scale.min(container.r);
 for _i in 0..iterations {
 let x: f64 = rng.gen_range(x1, x2);
 let y: f64 = rng.gen_range(y1, y2);
 if let Some(size) = search_circle_radius(&amp;container, &amp;circles, x, y, min_scale, max_scale) {
 let circle = VCircle::new(x, y, size - pad);
 // innovation happens here, basically we keep pushing until we reach the nb
 tries.push(circle);
 if tries.len() &gt; optimize_size {
 // then we grab the biggest
 tries.sort_by(|a, b| b.r.partial_cmp(&amp;a.r).unwrap());
 let c = tries[0];
 circles.push(c.clone());
 tries = Vec::new();
 }
 }
 if circles.len() &gt; desired_count {
 break;
 }
 }
 circles
}
</code></pre>