def led_visualization(onset_values):
# Visualizations that we want to use (normalized to ~[0, 1])
#pixels_A = update_leds_6(onset_values)
#pixels_B = update_leds_4(onset_values)
# Combine the effects by taking the product
#brightness = pixels_A #* pixels_B
brightness = update_leds_6(onset_values**2.0)
brightness = gaussian_filter1d(brightness, 4.0)
#brightness = hyperbolic_tan(brightness)
brightness = bloom_peaks(brightness)**2.
# Combine pixels with color map
color = rainbow_gen(onset_values.shape[0],
speed=1.,
center=0.5,
width=0.5,
f=[1.1, .5, .2]) * 255.0
color = np.tile(255.0, (config.N_PIXELS, 3))
# color = rainbow(onset_values.shape[0]) * 255.0
pixels = (brightness * color.T).T
pixels = leak_saturated_pixels(pixels)
pixels = np.clip(pixels, 0., 255.)
# Apply low-pass filter to the output
pixels_filt.update(np.copy(pixels))
# Display values on the LED strip
led.pixels = np.round(pixels_filt.value).astype(int)
led.update()
return brightness
def ambiance():
for i in range(config.N_PIXELS):
r[i] = 74
g[i] = 0
b[i] = 106
led.pixels = np.array([r, g, b])
led.update(components)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
print('No audio input. Volume below threshold. Volume:', vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualization_effect(mel)
led.pixels = output
led.update()
if config.USE_GUI:
# Plot filterbank output
x = np.linspace(config.MIN_FREQUENCY, config.MAX_FREQUENCY,
len(mel))
mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
# Plot the color channels
r_curve.setData(y=led.pixels[0])
g_curve.setData(y=led.pixels[1])
b_curve.setData(y=led.pixels[2])
int_led = led.pixels.astype(int)
combined_plot.setBrush([
get_qt_brush(rgb[0], rgb[1], rgb[2])
for rgb in np.stack([int_led[0], int_led[1], int_led[2]],
axis=1)
])
if config.USE_GUI:
app.processEvents()
if config.DISPLAY_FPS:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
print('FPS {:.0f} / {:.0f}'.format(fps, config.FPS))
def microphone_update(stream):
global y_roll, prev_rms, prev_exp
# Retrieve and normalize the new audio samples
try:
y = np.fromstring(stream.read(samples_per_frame), dtype=np.int16)
except IOError:
y = y_roll[config.N_ROLLING_HISTORY - 1, :]
global buffer_overflows
print('Buffer overflows: {0}'.format(buffer_overflows))
buffer_overflows += 1
# Seperates a stereo feed into the left and right streams,
# then pulls out the left channel for further processing
if config.USE_LOOPBACK:
y = np.reshape(y, (int(config.MIC_RATE / config.FPS), 2))
y = y[:, 0]
# Normalize samples between 0 and 1
y = y / 2.0**15
# Construct a rolling window of audio samples
y_roll = np.roll(y_roll, -1, axis=0)
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0)
volume.update(np.nanmean(y_data**2))
if volume.value < config.MIN_VOLUME_THRESHOLD:
print('No audio input. Volume below threshold. Volume:', volume.value)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
# Transform audio input into the frequency domain
XS, YS = dsp.fft(y_data, window=np.hamming)
# Remove half of the FFT data because of symmetry
YS = YS[:len(YS) // 2]
XS = XS[:len(XS) // 2]
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(np.abs(YS)).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
mel = np.mean(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel = mel / mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualization_effect(mel)
led.pixels = output
led.update()
if config.USE_GUI:
# Plot filterbank output
x = np.linspace(config.MIN_FREQUENCY, config.MAX_FREQUENCY,
len(mel))
mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
# Plot the color channels
r_curve.setData(y=led.pixels[0])
g_curve.setData(y=led.pixels[1])
b_curve.setData(y=led.pixels[2])
app.processEvents()
if config.DISPLAY_FPS:
print('FPS {:.0f} / {:.0f}'.format(frames_per_second(), config.FPS))
def CylonBounce(red, green, blue, EyeSize, SpeedDelay, ReturnDelay):
global r, g, b
for i in range(config.N_PIXELS - EyeSize - 2):
r[i] = red / 10
g[i] = green / 10
b[i] = blue / 10
for j in range(EyeSize):
r[i + j] = red
g[i + j] = green
b[i + j] = blue
r[i + EyeSize + 1] = red / 10
g[i + EyeSize + 1] = green / 10
b[i + EyeSize + 1] = blue / 10
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(SpeedDelay / 1000)
time.sleep(ReturnDelay / 1000)
for i in range(config.N_PIXELS - EyeSize - 2, 0, -1):
r[i] = red / 10
g[i] = green / 10
b[i] = blue / 10
for j in range(EyeSize):
r[i + j] = red
g[i + j] = green
b[i + j] = blue
r[i + EyeSize + 1] = red / 10
g[i + EyeSize + 1] = green / 10
b[i + EyeSize + 1] = blue / 10
led.update(components)
time.sleep(SpeedDelay / 1000)
time.sleep(ReturnDelay / 1000)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update
y = audio_samples / 2.0**15
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
print('No audio input. Volume below threshold. Volume:', vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
mel = np.atleast_2d(YS).T * dsp.mel_y.T
mel = np.sum(mel, axis=0)
mel = mel**2.0
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
output = visualization_effect(mel)
led.pixels = output
led.update()
def update_leds_now():
global updates_this_second
global strip_0_pixels, strip_1_pixels
global shift
shift = (shift + 0.01) % 1.0
updates_this_second += 1
for pixel_array in [strip_0_pixels, strip_1_pixels]: #really inefficient
for num in range(0, 100):
hsv = (colorsys.rgb_to_hsv(
float(pixel_array[0][num]) / 255,
float(pixel_array[1][num]) / 255,
float(pixel_array[2][num]) / 255))
pixel_array[0][num] = colorsys.hsv_to_rgb(
(hsv[0] + shift) % 1.0, hsv[1], hsv[2])[0] * 255
pixel_array[1][num] = colorsys.hsv_to_rgb(
(hsv[0] + shift) % 1.0, hsv[1], hsv[2])[1] * 255
pixel_array[2][num] = colorsys.hsv_to_rgb(
(hsv[0] + shift) % 1.0, hsv[1], hsv[2])[2] * 255
led.pixels[0][0:100] = np.flip(strip_0_pixels[0])
led.pixels[1][0:100] = np.flip(strip_0_pixels[1])
led.pixels[2][0:100] = np.flip(strip_0_pixels[2])
led.pixels[0][100:200] = (strip_1_pixels[0])
led.pixels[1][100:200] = (strip_1_pixels[1])
led.pixels[2][100:200] = (strip_1_pixels[2])
led.update()
def rainbow(wait_ms=20, iterations=1):
for j in range(256 * iterations):
for i in range(config.N_PIXELS):
r[i], g[i], b[i] = wheel(
round(((i * 256 / config.N_PIXELS) + j)) & 255)
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(wait_ms / 1000.0)
def clear():
global r, g, b
for i in range(config.N_PIXELS):
r[i] = 0
g[i] = 0
b[i] = 0
led.pixels = np.array([r, g, b])
led.update(components)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
if config.USE_GUI:
gui.label_error.setText("No audio input. Volume below threshold.")
else:
print("No audio input. Volume below threshold. Volume: {}".format(vol))
visualizer.prev_output = np.multiply(visualizer.prev_output,0.95)
led.pixels = visualizer.prev_output
led.update()
else:
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
led.pixels = visualizer.get_vis(mel)
led.update()
if config.USE_GUI:
# Plot filterbank output
x = np.linspace(config.MIN_FREQUENCY, config.MAX_FREQUENCY, len(mel))
gui.mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
gui.label_error.setText("")
if config.USE_GUI:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
app.processEvents()
# Plot the color channels
gui.r_curve.setData(y=led.pixels[0])
gui.g_curve.setData(y=led.pixels[1])
gui.b_curve.setData(y=led.pixels[2])
# Update fps counter
gui.label_fps.setText('{:.0f} / {:.0f} FPS'.format(fps, config.FPS))
if config.DISPLAY_FPS:
print('FPS {:.0f} / {:.0f}'.format(fps, config.FPS))
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update, n_frame
# Normalize samples between 0 and 1
y = audio_samples / 32767.0
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config['MIN_VOLUME_THRESHOLD']:
if config['TURN_OFF_ON_SILENCE']:
led.pixels = np.tile(0, (4, config['N_PIXELS']))
led.update(config)
else:
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = effects[config['SELECTED_VISUALIZATION'] % len(effects)](mel)
led.pixels = output
led.update(config)
n_frame += 1
if config['USE_GUI']:
# Plot filterbank output
x = np.linspace(config['MIN_FREQUENCY'], config['MAX_FREQUENCY'],
len(mel))
mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
# Plot the color channels
# r_curve.setData(y=led.pixels[0])
# g_curve.setData(y=led.pixels[1])
# b_curve.setData(y=led.pixels[2])
r_curve.setData(y=output[0])
g_curve.setData(y=output[1])
b_curve.setData(y=output[2])
if config['USE_GUI']:
app.processEvents()
if config['DISPLAY_FPS']:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
print('FPS {:.0f} / {:.0f}'.format(fps, config['FPS']))
def colorWipe(rcolor, gcolor, bcolor, wait_ms=50):
global r, g, b
"""Wipe color across display a pixel at a time."""
for i in range(config.N_PIXELS):
r[i] = rcolor
g[i] = gcolor
b[i] = bcolor
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(wait_ms / 1000.0)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
print('No audio input. Volume below threshold. Volume:', vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualization_effect(mel)
led.pixels = output
led.update()
if config.USE_GUI:
# Plot filterbank output
x = np.linspace(config.MIN_FREQUENCY, config.MAX_FREQUENCY, len(mel))
mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
# Plot the color channels
r_curve.setData(y=led.pixels[0])
g_curve.setData(y=led.pixels[1])
b_curve.setData(y=led.pixels[2])
if config.USE_GUI:
app.processEvents()
if config.DISPLAY_FPS:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
print('FPS {:.0f} / {:.0f}'.format(fps, config.FPS))
def start_everything():
global _audio_reader, _light_streamer
# Initialize LEDs to off
led.pixels = np.tile(1, (3, config.N_PIXELS))
led.update()
# Create audio queue
audio_queue = queue.Queue()
_audio_reader = microphone.AudioReader(audio_queue, config.MIC_RATE,
config.FPS)
_light_streamer = LightStreamer(audio_queue)
_audio_reader.start()
_light_streamer.start()
return
def theaterChaseRainbow(wait_ms=50):
for j in range(256):
for q in range(3):
for i in range(0, config.N_PIXELS, 3):
r[i + q], g[i + q], b[i + q] = wheel((i + j) % 255)
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(wait_ms / 1000.0)
for i in range(0, config.N_PIXELS, 3):
r[i + q] = 0
g[i + q] = 0
b[i + q] = 0
led.pixels = np.array([r, g, b])
def led_vis3(x):
energy = np.mean(x**.5)
pixels = np.tile(0.0, config.N_PIXELS)
for i in range(N):
E[i].update(energy)
pixels[i] = hyperbolic_tan(max(energy / E[i].value - 1.0, 0))
color = np.tile(0.0, (3, config.N_PIXELS))
color[0, :] = pixels
color[1, :] = pixels
color[2, :] = pixels
color = color.T * 255.0
pixels_filt.update(color)
led.pixels = np.round(pixels_filt.value).astype(int)
led.update()
return (color[:, 0] + color[:, 1] + color[:, 2]) / (3. * 255.0)
def theaterChase(rcolor, gcolor, bcolor, wait_ms):
global r, g, b
"""Movie theater light style chaser animation."""
for q in range(3):
for i in range(0, config.N_PIXELS, 3):
r[i + q] = rcolor
g[i + q] = gcolor
b[i + q] = bcolor
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(wait_ms / 1000.0)
for i in range(0, config.N_PIXELS, 3):
r[i + q] = 0
g[i + q] = 0
b[i + q] = 0
led.pixels = np.array([r, g, b])
def thunder():
for i in range(config.N_PIXELS):
r[i] = 255
g[i] = 255
b[i] = 153
led.pixels = np.array([r, g, b])
time.sleep(7 / 1000.0)
led.update(components)
for i in range(config.N_PIXELS):
r[i] = 0
g[i] = 0
b[i] = 0
led.pixels = np.array([r, g, b])
time.sleep(7 / 1000.0)
led.update(components)
def stop_everything():
global _audio_reader, _light_streamer
if _audio_reader and _audio_reader.is_alive():
_audio_reader.shutdown()
_audio_reader.join(1)
_audio_reader = None
pass
if _light_streamer and _light_streamer.is_alive():
_light_streamer.shutdown()
_light_streamer.join(1)
_light_streamer = None
pass
# Initialize LEDs to off
led.pixels = np.tile(1, (3, config.N_PIXELS))
led.update()
return
def Fire(Cooling, Sparking, SpeedDelay):
global heat
for i in range(config.N_PIXELS):
cooldown = randint(0, round(((Cooling * 10) / config.N_PIXELS) + 2))
if cooldown > heat[i]:
heat[i] = 0
else:
heat[i] = heat[i] - cooldown
for k in range(config.N_PIXELS - 1, 2, -1):
heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3
if randint(0, 255) < Sparking:
y = randint(0, 7)
heat[y] = randint(160, 255)
for j in range(config.N_PIXELS):
print(heat[j])
r[j], g[j], b[j] = setPixelHeatColor(heat[j])
led.pixels = np.array([r, g, b])
led.update(components)
time.sleep(SpeedDelay / 1000)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
logger.info('No audio input. Volume below threshold. Volume: %f' % vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
return
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualization_effect(mel)
led.pixels = output
led.update()
if config.DISPLAY_FPS:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
logger.info('FPS {:.0f} / {:.0f}'.format(fps, config.FPS))
return
def snow():
while True:
for i in range(len(rain_current)):
if rain_increasing[i]:
if rain_current[i] >= rain_goal[i]:
rain_increasing[i] = False
rain_current[i] -= 10
else:
rain_current[i] += 10
else:
if rain_current[i] != 0:
rain_current[i] -= 10
else:
temp = randrange(50, 200)
if temp % 32 == 0:
rain_goal[i] = temp
rain_increasing[i] = True
led.pixels = np.array([r, g, rain_current])
led.update(components)
time.sleep(50 / 1000.0)
def microphone_update(audio_samples):
global y_roll
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
print('No audio input. Volume below threshold. Volume:', vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = effect(mel)
led.pixels = output
led.update()
if config.USE_GUI:
gui.update(mel)
if config.USE_GUI:
app.processEvents()
def microphone_update(audio_samples):
global samples_roll
# Normalize samples between 0 and 1
normalised_samples = audio_samples / 2.0**15
# Construct a rolling window of audio samples
samples_roll[:-1] = samples_roll[1:]
samples_roll[-1, :] = np.copy(normalised_samples)
sample_data = np.concatenate(samples_roll, axis=0).astype(np.float32)
# Normalise Brightness from Amplitude
vol = np.max(np.abs(sample_data))
# Cancel noise when no sound is played
if vol < 0.0001:
vol = 0
print('No audio input. Volume below threshold. Volume:', vol)
led.pixels = np.tile(0, (3, config.N_PIXELS))
led.update()
else:
# Transform audio input into the frequency domain
N = len(sample_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N # 2^11 - 1470
# Pad with zeros until the next power of two
sample_data *= fft_window
sample_padded = np.pad(sample_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(sample_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
exp_filter.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= exp_filter.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualize_scroll(mel)
led.pixels = output
led.update()
def visualize(y):
y = np.copy(interpolate(y, config.N_PIXELS)) * 255.0
# Blur the color channels with different strengths
r = gaussian_filter1d(y, sigma=0.15)
g = gaussian_filter1d(y, sigma=2.0)
b = gaussian_filter1d(y, sigma=0.0)
# Take the geometric mean of the raw and normalized histograms
r = np.sqrt(r * normalize(r))
g = np.sqrt(g * normalize(g))
b = np.sqrt(b * normalize(b))
# Update the low pass filters for each color channel
r_filt.update(r)
g_filt.update(g)
b_filt.update(b)
# Update the LED strip values
led.pixels[:, 0] = r_filt.value
led.pixels[:, 1] = g_filt.value
led.pixels[:, 2] = b_filt.value
# Update the GUI plots
GUI.curve[0][0].setData(x=range(len(r_filt.value)), y=r_filt.value)
GUI.curve[0][1].setData(x=range(len(g_filt.value)), y=g_filt.value)
GUI.curve[0][2].setData(x=range(len(b_filt.value)), y=b_filt.value)
led.update()
def microphone_update(self, audio_samples):
"""
Update the leds and gui with the rgb values taken from the audio sample
"""
led.pixels, mel = self.audio_to_rgb(audio_samples)
led.update()
if self.configs['use_gui']:
# Plot filterbank output
x = np.linspace(self.configs['min_frequency'],
self.configs['max_frequency'], len(mel))
mel_curve.setData(x=x, y=self.fft_plot_filter.update(mel))
# Plot the color channels
r_curve.setData(y=led.pixels[0])
g_curve.setData(y=led.pixels[1])
b_curve.setData(y=led.pixels[2])
if self.configs['use_gui']:
app.processEvents()
if self.configs['display_fps']:
fps = frames_per_second()
if time.time() - 0.5 > self.prev_fps_update:
self.prev_fps_update = time.time()
print('FPS {:.0f} / {:.0f}'.format(fps, self.configs['fps']))
def radiate(beats, energy, beat_speed=.6, max_length=7, min_beats=1):
N_beats = len(beats[beats == True])
if N_beats > 0 and N_beats >= min_beats:
index_to_color = rainbow()
# Beat properties
beat_power = float(N_beats) / config.N_SUBBANDS
# energy = np.copy(energy)
# energy -= np.min(energy)
# energy /= (np.max(energy) - np.min(energy))
beat_brightness = np.round(256.0 / config.N_SUBBANDS)
beat_brightness *= np.sqrt(config.N_SUBBANDS / N_beats)
beat_brightness *= 1.3
beat_length = int(np.sqrt(beat_power) * max_length)
beat_length = max(beat_length, 2)
beat_pixels = np.tile(0.0, (config.N_PIXELS / 2, 3))
for i in range(len(beats)):
if beats[i]:
beat_color = np.round(index_to_color[i] * beat_brightness *
energy[i] / 2.0)
beat_pixels[:beat_length] += beat_color
beat_pixels = np.clip(beat_pixels, 0.0, 255.0)
beat = Beat(beat_pixels, beat_speed)
radiate.beats = np.append(radiate.beats, beat)
# Pixels that will be displayed on the LED strip
pixels = np.zeros((config.N_PIXELS / 2, 3))
if len(radiate.beats):
pixels += sum([b.pixels for b in radiate.beats])
for b in radiate.beats:
b.update_pixels()
radiate.beats = [b for b in radiate.beats if not b.finished()]
pixels = np.append(pixels[::-1], pixels, axis=0)
pixels = np.clip(pixels, 0.0, 255.0)
led.pixels = np.round(pixels).astype(int)
led.update()
def led_vis2(x):
energy = np.mean(x**.5)
mean_energy.update(energy)
energy = energy / mean_energy.value - 1.0
edge = np.exp(-10 * np.linspace(0, 1, len(x)))
edge = edge + edge[::-1]
edge *= max(energy, 0)
edge /= 2.0
x = gaussian_filter1d(x, 3.0)
x = update_leds_6(x)
red = bloom_peaks(x**1.0, width=1, blur_factor=1.5)
green = bloom_peaks(x**1.0, width=2, blur_factor=0.5)
blue = bloom_peaks(x**1.0, width=1, blur_factor=0.5)
# Set LEDs
color = np.tile(0.0, (3, config.N_PIXELS))
color[0, :] = 1.0 * edge + red * 1.0
color[1, :] = 1.2 * edge + green * 1.0
color[2, :] = 1.5 * edge + blue * 1.0
color = color.T * 255.0
pixels_filt.update(color)
led.pixels = np.round(pixels_filt.value).astype(int)
led.update()
return (color[:, 0] + color[:, 1] + color[:, 2]) / (3. * 255.0)
spectrum_label.setText('Spectrum', color=inactive_color)
def spectrum_click(x):
global visualization_effect
visualization_effect = visualize_spectrum
energy_label.setText('Energy', color=inactive_color)
scroll_label.setText('Scroll', color=inactive_color)
spectrum_label.setText('Spectrum', color=active_color)
# Create effect "buttons" (labels with click event)
energy_label = pg.LabelItem('Energy')
scroll_label = pg.LabelItem('Scroll')
spectrum_label = pg.LabelItem('Spectrum')
energy_label.mousePressEvent = energy_click
scroll_label.mousePressEvent = scroll_click
spectrum_label.mousePressEvent = spectrum_click
energy_click(0)
# Layout
layout.nextRow()
layout.addItem(freq_label, colspan=3)
layout.nextRow()
layout.addItem(freq_slider, colspan=3)
layout.nextRow()
layout.addItem(energy_label)
layout.addItem(scroll_label)
layout.addItem(spectrum_label)
# Initialize LEDs
led.update()
# Start listening to live audio stream
microphone.start_stream(microphone_update)
def microphone_update(audio_samples):
global y_roll, prev_rms, prev_exp, prev_fps_update, WheelPosition, silent_timeout, brigh
# Normalize samples between 0 and 1
y = audio_samples / 2.0**15
# Construct a rolling window of audio samples
y_roll[:-1] = y_roll[1:]
y_roll[-1, :] = np.copy(y)
y_data = np.concatenate(y_roll, axis=0).astype(np.float32)
vol = np.max(np.abs(y_data))
if vol < config.MIN_VOLUME_THRESHOLD:
#print('No audio input. Volume below threshold. Volume:', vol)
if WheelPosition < 256:
r_fact,g_fact,b_fact = Wheel(WheelPosition)
WheelPosition += 1
else:
WheelPosition = 0
r_fact,g_fact,b_fact = Wheel(WheelPosition)
r = np.ones((60,), dtype=int)*r_fact*brigh/400
g = np.ones((60,), dtype=int)*g_fact*brigh/400
b = np.ones((60,), dtype=int)*b_fact*brigh/400
led.pixels = np.array([r,g,b])
led.update()
if silent_timeout > 0:
silent_timeout -= 1
elif brigh < 400:
brigh += 1
else:
silent_timeout = 40
brigh = 0
# Transform audio input into the frequency domain
N = len(y_data)
N_zeros = 2**int(np.ceil(np.log2(N))) - N
# Pad with zeros until the next power of two
y_data *= fft_window
y_padded = np.pad(y_data, (0, N_zeros), mode='constant')
YS = np.abs(np.fft.rfft(y_padded)[:N // 2])
# Construct a Mel filterbank from the FFT data
mel = np.atleast_2d(YS).T * dsp.mel_y.T
# Scale data to values more suitable for visualization
# mel = np.sum(mel, axis=0)
mel = np.sum(mel, axis=0)
mel = mel**2.0
# Gain normalization
mel_gain.update(np.max(gaussian_filter1d(mel, sigma=1.0)))
mel /= mel_gain.value
mel = mel_smoothing.update(mel)
# Map filterbank output onto LED strip
output = visualization_effect(mel)
led.pixels = output
led.update()
if config.USE_GUI:
# Plot filterbank output
x = np.linspace(config.MIN_FREQUENCY, config.MAX_FREQUENCY, len(mel))
mel_curve.setData(x=x, y=fft_plot_filter.update(mel))
# Plot the color channels
r_curve.setData(y=led.pixels[0])
g_curve.setData(y=led.pixels[1])
b_curve.setData(y=led.pixels[2])
if config.USE_GUI:
app.processEvents()
if config.DISPLAY_FPS:
fps = frames_per_second()
if time.time() - 0.5 > prev_fps_update:
prev_fps_update = time.time()
print('FPS {:.0f} / {:.0f}'.format(fps, config.FPS))
energy_label.setText('Energy', color=inactive_color)
scroll_label.setText('Scroll', color=active_color)
spectrum_label.setText('Spectrum', color=inactive_color)
def spectrum_click(x):
global visualization_effect
visualization_effect = visualize_spectrum
energy_label.setText('Energy', color=inactive_color)
scroll_label.setText('Scroll', color=inactive_color)
spectrum_label.setText('Spectrum', color=active_color)
# Create effect "buttons" (labels with click event)
energy_label = pg.LabelItem('Energy')
scroll_label = pg.LabelItem('Scroll')
spectrum_label = pg.LabelItem('Spectrum')
energy_label.mousePressEvent = energy_click
scroll_label.mousePressEvent = scroll_click
spectrum_label.mousePressEvent = spectrum_click
energy_click(0)
# Layout
layout.nextRow()
layout.addItem(freq_label, colspan=3)
layout.nextRow()
layout.addItem(freq_slider, colspan=3)
layout.nextRow()
layout.addItem(energy_label)
layout.addItem(scroll_label)
layout.addItem(spectrum_label)
# Initialize LEDs
led.update()
# Start listening to live audio stream
microphone.start_stream(microphone_update)
def visualization_start():
# Initialize LEDs
led.update()
# Start listening to live audio stream
microphone.start_stream(microphone_update)
