def test_StreamCollection(self):
a = Stream([0, 1, 2, 3])
b = Stream([5, 6, 7, 8])
c = Stream([-1, -2, -3])
coll = StreamCollection([a, b, c])
self.assertEquals(a.peek(4), coll.take(4))
self.assertEquals(b.peek(4), coll.take(4))
self.assertEquals(c.peek(3), coll.take(3))
def get_fundfreq(fs, audio, order=12, mode='covariance'):
import audiolazy as AL
from audiolazy import Stream
modes = {'covariance', 'autocorrelation'}
if mode not in modes:
raise Exception(
"The value for mode needs to be either 'covariance' or 'autocorrelation'"
)
if mode == 'covariance':
filt_func = AL.lpc.covariance
if mode == 'autocorrelation':
filt_func = AL.lpc.autocorrelation
inv_filt = filt_func(audio, order)
sig = audio.copy()
sig_ = inv_filt(Stream(sig)).take(len(sig))
sub = sig - sig_
autocorr = np.correlate(sub, sub, 'same')
autocorr = autocorr[int(len(autocorr) / 2):]
ind_locmax = np.squeeze(argrelextrema(autocorr, np.greater))
locmax = autocorr[ind_locmax]
pitch_period = ind_locmax[np.argmax(locmax)]
fundamental_freq = fs / pitch_period
return fundamental_freq
def taylor(f, n=2, **kwargs):
"""
Taylor/Mclaurin polynomial aproximation for the given function.
The ``n`` (default 2) is the amount of aproximation terms for ``f``. Other
arguments are keyword-only and will be passed to the ``f.series`` method.
"""
return sum(Stream(f.series(n=None, **kwargs)).limit(n))
def get_peaks(blk, neighbors=2):
"""
Get all peak indices in blk (sorted by index value) but the ones at the
vector limits (first and last ``neighbors - 1`` values). A peak is the max
value in a neighborhood of ``neighbors`` values for each side.
"""
size = 1 + 2 * neighbors
pairs = enumerate(Stream(blk).blocks(size=size, hop=1).map(list), neighbors)
for idx, nbhood in pairs:
center = nbhood.pop(neighbors)
if all(center >= el for el in nbhood):
yield idx
next(pairs) # Skip ones we already know can't be peaks
next(pairs)
def mgl_seq(x):
"""
Sequence whose sum is the Madhava-Gregory-Leibniz series.
[x, -x^3/3, x^5/5, -x^7/7, x^9/9, -x^11/11, ...]
Returns
-------
An endless sequence that has the property
``atan(x) = sum(mgl_seq(x))``.
Usually you would use the ``atan()`` function, not this one.
"""
odd_numbers = thub(count(start=1, step=2), 2)
return Stream(1, -1) * x ** odd_numbers / odd_numbers
def test(filepath):
fs, audio = wavread(filepath)
# IPython.display.Audio(filepath)
import audiolazy as AL
from audiolazy import Stream
filt = AL.lpc.covariance(audio, order=10)
sig = audio.copy()
s = Stream(audio.copy())
sig_ = filt(s).take(len(sig))
N = -600
plt.subplot(211)
plt.plot(sig[N:], linewidth=0.5, label='Original signal $s[n]$')
plt.plot(sig_[N:],
linewidth=0.5,
label=u'Filtered $\hat{s}[n]$',
alpha=0.5)
plt.title(filepath)
plt.legend()
plt.subplot(212)
plt.plot(sig[N:] - sig_[N:], linewidth=0.5, label=u'$s[n] - \hat{s}[n]$')
plt.legend()
def limiter(sig, threshold=.1, size=256, env=envelope.rms, cutoff=pi / 2048):
sig = thub(sig, 2)
return sig * Stream(1. if el <= threshold else threshold / el
for el in maverage(size)(env(sig, cutoff=cutoff)))
# along with this program. If not, see <http://www.gnu.org/licenses/>. """ LPTV (Linear Periodically Time Variant) filter example (a.k.a. PLTV) """ from audiolazy import sHz, sinusoid, Stream, AudioIO, z, pi, chunks import time, sys # Basic initialization rate = 44100 s, Hz = sHz(rate) # Some time-variant coefficients cycle_a1 = [.1, .2, .1, 0, -.1, -.2, -.1, 0] cycle_a2 = [.1, 0, -.1, 0, 0] a1 = Stream(*cycle_a1) a2 = Stream(*cycle_a2) * 2 b1 = sinusoid(18 * Hz) # Sine phase b2 = sinusoid(freq=7 * Hz, phase=pi / 2) # Cosine phase # The filter filt = (1 + b1 * z**-1 + b2 * z**-2 + .7 * z**-5) filt /= (1 - a1 * z**-1 - a2 * z**-2 - .1 * z**-3) # A really simple input input_data = sinusoid(220 * Hz) # Let's play it! api = sys.argv[1] if sys.argv[1:] else None # Choose API via command-line chunks.size = 1 if api == "jack" else 16 with AudioIO(api=api) as player:
def dft_pitch(sig, size=2048, hop=None):
for blk in Stream(sig).blocks(size=size, hop=hop):
dft_data = rfft(blk)
idx, vmax = max(enumerate(dft_data),
key=lambda el: abs(el[1]) / (2 * el[0] / size + 1))
yield 2 * pi * idx / size
def overlap_correlation(wnd, hop):
""" Overlap correlation percent for the given overlap hop in samples. """
return sum(wnd * Stream(wnd).skip(hop)) / sum(el**2 for el in wnd)
#!/usr/bin/env python
# coding: utf-8
# MIT Licenced
# @authors: Danilo J. S. Bellini
# Eduardo F. Mendes
# Renato G. Rodrigues
# Victor Mendizabal
# Otto Heringer
# Danilo Vieira
#
# Regular time-alternated one-LED blinking with AudioLazy for Raspberry Pi
import RPi.GPIO as gpio
from time import sleep
from audiolazy import Stream
gpio.setmode(gpio.BOARD)
gpio.setup(11, gpio.OUT)
for idx, delay in enumerate(Stream(1, 2, 2, 1)):
gpio.output(11, int(idx % 2 == 0))
sleep(delay * .2)