added app

app.py

@@ -0,0 +1,111 @@
+import numpy as np
+from scipy.fft import fftn, ifftn, fftshift, fftfreq
+import streamlit as st
+import matplotlib.pyplot as plt
+import subprocess
+
+image_seed = st.sidebar.slider("Image Seed", 0, 10000, 0)
+transform_seed = st.sidebar.slider("Transform Seed", 0, 10000, 0)
+transform_level = st.sidebar.slider("Transform Level", 0.0, 100.0, 0.0)
+
+
+def random_channel(n, rand, fpower=2.0):
+    freq = fftn(rand.rand(n, n))
+
+    fx = fftfreq(n)[:, None]
+    fy = fftfreq(n)[None, :]
+
+    # combine as l2 norm of freq
+    f = (fx**2 + fy**2) ** 0.5
+
+    i = f > 0
+    freq[i] /= f[i] ** fpower
+    freq[0, 0] = 0.0
+
+    data = np.real(ifftn(freq))
+    data -= data.min()
+    data /= data.max()
+    return data
+
+
+@st.cache_data
+def random_gray(n, seed, fpower=2.0):
+    rand = np.random.RandomState(seed)
+    return random_channel(n, rand, fpower)
+
+
+@st.cache_data
+def random_color(n, seed):
+    rand = np.random.RandomState(seed)
+    return np.stack([random_channel(n, rand) for _ in range(3)], 2)
+
+
+def rotate_image(img, i, j, a):
+    c = np.cos(a)
+    s = np.sin(a)
+
+    img = 2.0 * img - 1.0
+    x, y = img[:, :, i], img[:, :, j]
+    img[:, :, i], img[:, :, j] = c * x + s * y, -s * x + c * y
+    img -= img.min()
+    img /= img.max()
+    return img
+
+
+n = 512
+img = random_color(n, image_seed)
+
+a = random_color(n, transform_seed) * transform_level
+img = rotate_image(img, 0, 1, a[:, :, 0])
+img = rotate_image(img, 0, 2, a[:, :, 1])
+img = rotate_image(img, 1, 2, a[:, :, 2])
+
+"""
+# Output
+
+Play around with the parameters on the left to change the image.
+"""
+
+st.image(img, width=600)
+
+"""
+The image is generated as follows:
+
+1. Generate 6D cube of "brownian noise". We'll name these coordinates (R, G, B, A1, A2, A3).
+2. Apply a rotation of angle A1*Level to (R, G) plane.
+3. Apply a rotation of angle A2*Level to (R, B) plane.
+4. Apply a rotation of angle A3*Level to (G, B) plane.
+5. The resulting (R, G, B) data is the image.
+
+# Background
+
+I was inspired to write this after seeing some neat examples from the [accidental noise library](http://accidentalnoise.sourceforge.net).
+
+My approach to doing this was:
+
+1. Generate nice looking 2D noise. I found that a 2D analog of [brownian noise](https://en.wikipedia.org/wiki/Colors_of_noise#Brownian_noise) looked pretty good.
+2. Stack 6 independent channels to form the 6D cube.
+3. Apply the rotations outlined above.
+
+Out of these steps, I found the most interesting bit to be generating the 2D noise.
+
+There seem to be many approaches for doing this, including classic approaches like [Perlin](https://en.wikipedia.org/wiki/Perlin_noise) and [Simplex](https://en.wikipedia.org/wiki/Simplex_noise) noise. Since I had access to good numeric libraries, I ended up going straight to the following FFT based approach.
+
+First, we generate a 2D image of uniformly sampled random noise. It pretty much looks like the static on your TV a.k.a. white noise.
+"""
+
+st.image(random_gray(512, 32, 0.0))
+
+"""
+White noise looks pretty harsh, so we want to smooth it out to get brownian noise.
+
+To do this, we take the 2D FFT to get to the frequency domain and then rescale things so they fall off like 1/f^2. To be nitpicky, I only found a general definition of brownian noise in 1D. Still... we're doing something very similar by rescaling by "one over the Euclidean norm squared".
+
+Finally, we take the inverse 2D FFT to get our image back.
+"""
+
+st.image(random_gray(512, 32))
+
+"""
+Noice!
+"""

requirements.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+matplotlib
+streamlit