{"id":465,"date":"2018-09-30T23:59:00","date_gmt":"2018-10-01T04:59:00","guid":{"rendered":"http:\/\/wordpress.cs.vt.edu\/ccs2018f\/?p=465"},"modified":"2018-09-30T21:50:34","modified_gmt":"2018-10-01T02:50:34","slug":"dsp-without-the-formalism","status":"publish","type":"post","link":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/2018\/09\/30\/dsp-without-the-formalism\/","title":{"rendered":"DSP: Without the Formalism"},"content":{"rendered":"

<\/p>\n

1\u00a0<\/span>Introduction<\/h3>\n

<\/p>\n

Today, we\u2019re going to be taking a brief look at digital signal processing (DSP) without (too much of) the
\nformalism usually associated with the topic. Of course, to get a deep understanding of how this works
\nand what sort of things you can really do with DSP you\u2019ll probably have to learn the math at a
\ndeeper level eventually. There\u2019s still plenty you can do without that however, and by the time you\u2019ve
\nread this post, you should have the tools to build an extremely basic beat detector. All the code
\nhere will be presented in Python, using the Numpy<\/span><\/a>, SciPy<\/span><\/a> and matplotlib<\/span><\/a> libraries. If you don\u2019t
\nalready have those installed and want to follow along, make sure you grab them first. On many
\nsystems this is as easy as using pip install numpy matplotlib <\/span>or installing a SciPy distribution like
\nAnaconda<\/span><\/a>. Before we dive directly into the code though, we do need to take a short trip through the
\nmath.
\n<\/p>\n

2 <\/span> <\/a>The Math<\/h3>\n

<\/p>\n

The beautiful (and in some ways terrible) thing about signal processing, is that we really only need one
\nmathematical tool: the Fourier transform<\/a>. Strictly speaking, we will be working with the discrete Fourier<\/span>
\ntransform <\/span>(DFT) here. This is great because we really only need to understand one thing which is so commonly
\nused that it is already available in library form for almost any platform or programming language you could
\nimagine. Unfortunately, that means there is a lot to unpack here. We will really only be taking the 30,000 foot
\nview today.
\n<\/p>\n

At it\u2019s heart, the Forier transform converts between what we call the time domain <\/span>and something
\ncalled the frequency domain<\/span>. It turns out that any \u201csignal\u201d: your voice, Rebecca Black\u2019s Friday, a
\nfinger painting, or Picasso\u2019s Mona Lisa, can be represented as a sum of sin waves. This result is not
\nat all obvious, but I promised to skip the formalism so we\u2019ll just have to take it on faith for now.
\nWe can see this at work by playing with a few examples though. The most obvious is simply a sin
\nwave:
\n<\/p>\n

\"\"<\/a>
\n<\/p>\n

We can see that the Forier transform is telling us exactly what we expect: all the frequency content of the
\nsignal is focused at a single point. What about something like a square wave?
\n<\/p>\n

\"\"<\/a>
\n<\/p>\n

There are a couple interesting things to note here. First, there is clearly a pattern in the DFT. This pattern
\ncan be described quite elegantly mathematically, and I encourage anyone who is so inclined to read up on that
\n(and the Fourier transform itself). Second, note that the frequency axis ranges from 0Hz to 250Hz. This is because
\nthe discrete version of the Fourier transform can only give us information about the spectral content up to half of
\nthe sampling frequency (which is 500Hz here). If you\u2019re interested in why this is the case, check out the wikiepdia article on the
\nNyquist rate<\/a>. The final thing to note is that I have been plotting three lines on these plots: The
\nsignal itself on top, and then two components of the DFT. Those components have been labeled
\nmag(dft(f)) <\/span>and angle(dft(f))<\/span>. This is because the Fourier transform actually produces two pieces of
\ninformation about the sin waves that compose a signal: the magnitude <\/span>(amount) of each sin wave, and
\nthe phase <\/span>(offset in time) of that wave. By leveraging both of these components, you can build
\nmuch more sophisticated DSP systems chains than the ones we will be building today. Before we
\nwrap up this section, I\u2019d like to take a brief moment to go over the code I used to generate these
\nplots.
\n<\/p>\n

The first thing we need to do is import all of the tools we\u2019ll need:
\n<\/p>\n

<\/a>import<\/span><\/span>\u00a0<\/span>numpy<\/span><\/span>\u00a0<\/span>as<\/span><\/span>\u00a0<\/span>np<\/span><\/span>
<\/a>from<\/span><\/span>\u00a0<\/span>numpy<\/span><\/span>\u00a0<\/span>import<\/span><\/span>\u00a0fft<\/span>
<\/a>from<\/span><\/span>\u00a0<\/span>math<\/span><\/span>\u00a0<\/span>import<\/span><\/span>\u00a0pi<\/span>
<\/a>from<\/span><\/span>\u00a0<\/span>matplotlib<\/span><\/span>\u00a0<\/span>import<\/span><\/span>\u00a0pyplot<\/span>\u00a0<\/span>as<\/span><\/span>\u00a0plt<\/span><\/div>\n

<\/p>\n

The fft <\/span>stands for \u201cFast Fourier Transform\u201d, and is essentially the DFT we have been discussing. We also
\nneed to generate our signals:
\n<\/p>\n

<\/a>#<\/span>\u00a0Generate<\/span>\u00a01000<\/span>\u00a0time<\/span>\u00a0values,<\/span>\u00a0evenly<\/span>\u00a0spaced<\/span>\u00a0from<\/span>\u00a00<\/span>\u00a0to<\/span>\u00a04<\/span>\u00a0seconds<\/span><\/span>
<\/a>t<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>linspace(<\/span>0<\/span><\/span>,<\/span>\u00a0<\/span>4<\/span><\/span>,<\/span>\u00a0<\/span>1000<\/span><\/span>)<\/span>
<\/a>fx<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>sin(t<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0<\/span>2<\/span><\/span>\u00a0<\/span>*<\/span><\/span>\u00a0pi)<\/span><\/div>\n

<\/p>\n

Then we need to compute the different statistics we\u2019re interested in from the Fourier transform
\n<\/p>\n

<\/a>hx<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0fft<\/span>.<\/span><\/span>rfft(fx)<\/span>
<\/a>hx_mag<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>abs(hx)<\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0<\/span>len<\/span><\/span>(fx)<\/span>
<\/a>hx_dir<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>angle(hx,<\/span>\u00a0deg<\/span>=<\/span><\/span>True<\/span><\/span>)<\/span><\/div>\n

<\/p>\n

A few minor details:<\/p>\n

    \n
  1. We use rfft <\/span>here because our signal only contains real values. If you don\u2019t know what that means,
    \nno worries. Just know that it will save us some cleaning up of the output later.<\/li>\n
  2. We compute the magnitude of the outputs using np.abs<\/span>. This has to do with the fact that the output
    \nof the Fourier transform is actually a bunch of complex numbers. We also divide by the length of the
    \ninput signal for normalization purposes. Again, the details don\u2019t really matter too much here.<\/li>\n
  3. Numpy has a convenient function for computing angles from complex numbers, so we just use that.
    \nThe deg=True <\/span>keyword argument simply tells NumPy to output the angles in degrees, for more
    \nintuitive plotting.<\/li>\n<\/ol>\n

    <\/p>\n

    Now that we have something of a foundation, let\u2019s take a look at how we might go about using this tool to
    \nanalyze some music<\/p>\n

    <\/p>\n

    3 <\/span> <\/a>Musical Analysis<\/h3>\n

    <\/p>\n

    To start with, we load some music into our program. I\u2019ll be working with Rogers & Dean – No Doubt (Rival x
    \nCadmium Remix)<\/a> which is an electronic piece, released for non-commercial use by NoCopyrightSounds. I have
    \nchosen this piece because it has a number of distinctive features in the soundscape, and a strong baseline which
    \nshould help our beat detector. First, we should load up all the data we\u2019re going to need, and clean it up a
    \nlittle
    \n<\/p>\n

    <\/a>from<\/span><\/span>\u00a0<\/span>scipy.io<\/span><\/span>\u00a0<\/span>import<\/span><\/span>\u00a0wavfile<\/span>
    <\/a>import<\/span><\/span>\u00a0<\/span>numpy<\/span><\/span>\u00a0<\/span>as<\/span><\/span>\u00a0<\/span>np<\/span><\/span>
    <\/a>
    <\/a>fs,<\/span>\u00a0signal<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0wavfile<\/span>.<\/span><\/span>read(<\/span>‘song.wav’<\/span><\/span>)<\/span>
    <\/a>WINDOW_SIZE<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0fs<\/span>\u00a0<\/span>\/\/<\/span><\/span>\u00a0<\/span>8<\/span><\/span>
    <\/a>
    \n
    <\/a>#<\/span>\u00a0colapse<\/span>\u00a0all<\/span>\u00a0the<\/span>\u00a0channels<\/span><\/span>
    <\/a>signal<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>mean(signal,<\/span>\u00a0<\/span>1<\/span><\/span>)<\/span>
    <\/a>#<\/span>\u00a0Normalize<\/span>\u00a0to<\/span>\u00a0[-1,<\/span>\u00a01]<\/span><\/span>
    <\/a>signal<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0signal<\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0(np<\/span>.<\/span><\/span>max(np<\/span>.<\/span><\/span>abs(signal)))<\/span><\/div>\n

    <\/p>\n

    The most obvious thing to do right now is to simply take the DFT of the whole piece.
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    Unfortunately, that doesn\u2019t provide us with terribly useful information. We can see that the phase content
    \nis all over the place, and the magnitude data is not terribly interesting: it mostly just looks like a
    \ndecaying exponential function. Instead of taking the DFT of the whole song, it\u2019s much more common
    \nto take the DFT of small sections of it at a time. Sometimes it\u2019s useful for the chunks to overlap, but we won\u2019t be doing that here just for
    \nconciseness. We will divide the song up into 1\/8th – second
    \nchunks using the following code:
    \n<\/p>\n

    <\/a>#<\/span>\u00a0Make<\/span>\u00a0sure<\/span>\u00a0that<\/span>\u00a0our<\/span>\u00a0signal<\/span>\u00a0is<\/span>\u00a0of<\/span>\u00a0appropriate<\/span>\u00a0length<\/span>\u00a0to<\/span>\u00a0split<\/span>\u00a0into<\/span>\u00a0windows<\/span><\/span>
    \n
    <\/a>signal<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>pad(signal,<\/span>\u00a0((<\/span>0<\/span><\/span>,<\/span>\u00a0WINDOW_SIZE<\/span>\u00a0<\/span>–<\/span><\/span>\u00a0(<\/span>len<\/span><\/span>(signal)<\/span>\u00a0<\/span>%<\/span><\/span>\u00a0WINDOW_SIZE))),<\/span>\u00a0<\/span>‘constant’<\/span><\/span>)<\/span>
    <\/a>
    \n
    <\/a>windows<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>array(np<\/span>.<\/span><\/span>split(signal,<\/span>\u00a0<\/span>len<\/span><\/span>(signal)<\/span>\u00a0<\/span>\/\/<\/span><\/span>\u00a0WINDOW_SIZE))<\/span>.<\/span><\/span>transpose()<\/span><\/div>\n

    <\/p>\n

    We can then take the DFT of each chunk:
    \n<\/p>\n

    <\/a>spectral_content<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0fft<\/span>.<\/span><\/span>rfft(windows,<\/span>\u00a0axis<\/span>=<\/span><\/span>0<\/span><\/span>)<\/span><\/div>\n

    <\/p>\n

    and then plot all of these as a big image:
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    Here we can see the hints of some interesting things going on along the bottom of the image. However, it
    \ninitially appears as though most of the image is empty. To demonstrate that this is not the case, I
    \nhave provided a plot with some of the horizontal and vertical lines extracted. The magnitude is
    \nplotted in purple for all of charts, while the angle is in blue. The charts are arranged so that the
    \nbottom-most line chart corresponds to the lowest line, and lines are parallel with the chart representing that
    \nslice
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    Note that as we go up through the frequency spectrum, the magnitudes decrease exponentially. This makes
    \nsense given our source of data \u2013 music. While the precise sensitivity of the human ear to different frequencies is
    \nnot precisely known (and may in fact depend on the overall spectral content of the signal, creating a highly
    \ncomplex and nonlinear dynamic) we are fairly sure that it is at least roughly sensitive to the logarithm of the
    \nincoming energy. We would like to make our magnitude values \u201cperceptually linear\u201d. That is, we would like to
    \napply some function to the magnitudes at each frequency to make an increase in magnitude at any frequency to
    \nresult in the same perceived increase in loudness to the sound at that frequency. To do that, we\u2019ll apply the
    \ntransformation below
    \n<\/p>\n

    <\/a>#<\/span>\u00a0Energy<\/span>\u00a0scales<\/span>\u00a0linearly<\/span>\u00a0with<\/span>\u00a0frequency<\/span><\/span>
    <\/a>freq_scaling<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>linspace(<\/span>0<\/span><\/span>,<\/span>\u00a0fs<\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0<\/span>2<\/span><\/span>,<\/span>\u00a0normed_spectral_content<\/span>.<\/span><\/span>shape[<\/span>0<\/span><\/span>])<\/span>
    \n
    <\/a>#<\/span>\u00a0Magic<\/span>\u00a0to<\/span>\u00a0make<\/span>\u00a0numpy<\/span>\u00a0happy<\/span><\/span>
    <\/a>freq_scaling<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0freq_scaling<\/span>.<\/span><\/span>reshape((sample_size,<\/span>\u00a0<\/span>1<\/span><\/span>))<\/span>
    \n
    <\/a>#<\/span>\u00a0“Perceptually<\/span>\u00a0linear”<\/span>\u00a0version:<\/span>\u00a0log<\/span>\u00a0of<\/span>\u00a0the<\/span>\u00a0incoming<\/span>\u00a0energy<\/span><\/span>
    \n
    <\/a>#<\/span>\u00a0We<\/span>\u00a0also<\/span>\u00a0add<\/span>\u00a0a<\/span>\u00a0tiny<\/span>\u00a0offset,<\/span>\u00a0just<\/span>\u00a0to<\/span>\u00a0avoid<\/span>\u00a0dealing<\/span>\u00a0with<\/span>\u00a0entries<\/span><\/span>
    <\/a>#<\/span>\u00a0that<\/span>\u00a0have<\/span>\u00a0zero<\/span>\u00a0energy<\/span><\/span>
    \n
    <\/a>pl<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>log(freq_scaling<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0normed_spectral_content<\/span>\u00a0<\/span>+<\/span><\/span>\u00a0<\/span>0.0001<\/span><\/span>)<\/span><\/div>\n

    <\/p>\n

    This gives us the graph below:
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    Note that we dropped the colors for the supplementary charts. That’s because we discarded all the phase information when converting to perceptual linearity. However, we did gain quite a bit of dynamic range in the process. unfortunately, due to the length of the waterfall plot, we can\u2019t really see
    \nthe fine detail we might be interested in. I\u2019m going to zoom in on just a handful of the samples near the beginning of the piece so we can get a
    \nmore detailed picture. The vertical line is still in the same place, relatively speaking:
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    And now at last, we can see the feature we\u2019re looking for: the beats (those vertical stripes of bright yellow).
    \n<\/p>\n

    4 <\/span> <\/a>A Really Bad Beat Detector<\/h3>\n

    <\/p>\n

    To finish out this post, we\u2019re going to build a really bad beat detector. Hopefully the techniques presented here
    \nwill help you develop your own, less terrible, beat detector (or other music-reactive project). The first thing to note is that we
    \nare going to be heavily summarizing the data; we must collapse the data from over 3000 measurements
    \nper time slice to just one bit: is there or is there not a beat start here. To start, we will summarize the amount of \u201cloudness\u201d in the \u201clow\u201d,
    \n\u201cmid\u201d, and \u201chigh\u201d bands. This will give us a number of time-domain signals which, when all of
    \nthem cross a given threshold, indicate beats. Putting this all together, we get the following bit of
    \npython:
    \n<\/p>\n

    <\/a>#<\/span>\u00a0Summarize<\/span>\u00a0data<\/span><\/span>
    <\/a>#<\/span>\u00a0Our<\/span>\u00a0buckets<\/span>\u00a0will<\/span>\u00a0be<\/span>\u00a0roughly:<\/span><\/span>
    <\/a>#<\/span>\u00a00<\/span>\u00a0–<\/span>\u00a0100<\/span>\u00a0Hz<\/span><\/span>
    <\/a>#<\/span>\u00a0101<\/span>\u00a0–<\/span>\u00a02<\/span>\u00a0Khz<\/span><\/span>
    <\/a>#<\/span>\u00a02Khz<\/span>\u00a0–<\/span>\u00a020Khz<\/span><\/span>
    \n
    <\/a>div1<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0<\/span>int<\/span><\/span>(sample_size<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0(<\/span>100<\/span><\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0(fs<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0<\/span>2<\/span><\/span>)))<\/span>
    <\/a>div2<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0<\/span>int<\/span><\/span>(sample_size<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0(<\/span>2000<\/span><\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0(fs<\/span>\u00a0<\/span>*<\/span><\/span>\u00a0<\/span>2<\/span><\/span>)))<\/span>
    <\/a>
    \n
    <\/a>SEG_START<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0<\/span>100<\/span><\/span>
    <\/a>SEG_END<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0<\/span>300<\/span><\/span>
    <\/a>
    <\/a>def<\/span><\/span>\u00a0<\/span>summarize<\/span><\/span>(start,<\/span>\u00a0stop):<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>#<\/span>\u00a0Select<\/span>\u00a0the<\/span>\u00a0right<\/span>\u00a0part<\/span>\u00a0of<\/span>\u00a0the<\/span>\u00a0array<\/span><\/span>
    \n
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0tr<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>sum(pl[start:stop,SEG_START:SEG_END],<\/span>\u00a0axis<\/span>=<\/span><\/span>0<\/span><\/span>)<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>#<\/span>\u00a0Compute<\/span>\u00a0a<\/span>\u00a0moving<\/span>\u00a0average<\/span>\u00a0(window<\/span>\u00a0size<\/span>\u00a0=<\/span>\u00a016)<\/span><\/span>
    \n
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>#<\/span>\u00a0to<\/span>\u00a0smooth<\/span>\u00a0out<\/span>\u00a0measurements<\/span><\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0MA_SIZE<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0<\/span>3<\/span><\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0tr<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>cumsum(tr)<\/span>
    \n
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0tr[MA_SIZE:]<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0tr[MA_SIZE:]<\/span>\u00a0<\/span>–<\/span><\/span>\u00a0tr[:<\/span>–<\/span><\/span>MA_SIZE]<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0tr<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0tr[MA_SIZE<\/span>–<\/span><\/span>1<\/span><\/span>:]<\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0MA_SIZE<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>#<\/span>\u00a0Normalize<\/span>\u00a0the<\/span>\u00a0moving<\/span>\u00a0average<\/span><\/span>
    \n
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0mi<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>min(tr)<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0ma<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0np<\/span>.<\/span><\/span>max(tr)<\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>#<\/span>\u00a0Normalize<\/span>\u00a0TR<\/span><\/span>
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0tr<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0(tr<\/span>\u00a0<\/span>–<\/span><\/span>\u00a0mi)<\/span>\u00a0<\/span>\/<\/span><\/span>\u00a0(ma<\/span>\u00a0<\/span>–<\/span><\/span>\u00a0mi)<\/span>
    \n
    <\/a>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>\u00a0<\/span>return<\/span><\/span>\u00a0tr<\/span>
    <\/a>
    <\/a>sum0<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0summarize(<\/span>0<\/span><\/span>,<\/span>\u00a0div1)<\/span>
    <\/a>sum1<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0summarize(div1,<\/span>\u00a0div2)<\/span>
    <\/a>sum2<\/span>\u00a0<\/span>=<\/span><\/span>\u00a0summarize(div2,<\/span>\u00a0<\/span>–<\/span><\/span>1<\/span><\/span>)<\/span><\/div>\n

    <\/p>\n

    We can see how well this works by looking at the plot below:
    \n<\/p>\n

    \"\"<\/a>
    \n<\/p>\n

    So we can see that a simple threshold approach might work, assuming we set enough thresholds with enough
    \nbins. However, we then run the risk of over-tuning our algorithm on this specific song. If we look
    \nback at the plot of just the raw time-domain signal, we can see that the overall magnitude of the
    \npiece varies significantly. That variance is at the root of the problem here: the varying volume means we need
    \nto also vary the threshold for what is considered a \u201cbeat\u201d. This can be accomplished using digital
    \nimplementations of things like     envelope followers<\/a>. If you want more detail about that\u00a0 approach, check out this beat detector from
    \nRice University<\/a>.<\/p>\n

    <\/p>\n

    5 <\/span> <\/a>Conclusion<\/h3>\n

    <\/p>\n

    This blog post is getting really long, so I\u2019m going to wrap it up here. Hopefully you have at least
    \nglimpsed the power of the Fourier transform, and have some desire to learn more about it. There are
    \nthousands of different filters and algorithms out there, but at the end of the day they all come down to
    \nwhat we did here: munging about with the data in the frequency domain. Some algorithms, like
    \n    FIR filters<\/a> work only in the time domain, but hidden behind that facade is a frequency-domain
    \ntransformation. Doing things in the time domain directly can be more efficient, but it\u2019s usually harder
    \nto figure out what\u2019s going on and is a less general approach. With the Fourier transform, we can
    \ndirectly inspect the frequency content of signals. While I didn\u2019t have a chance to talk about it today,
    \nthe DFT is actually invertable: you can reconstruct the original signal from its DFT. Several data
    \nstorage formats, including MP3 and JPEG, actually use a close cousin of the DFT (the discrete
    \ncosine transform or DCT) to compress data. If you want to learn more,     this online course<\/a> is a good
    \nresource.
    \n<\/p>\n

    All the code for this article is available here, on github<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"

    1\u00a0Introduction Today, we\u2019re going to be taking a brief look at digital signal processing (DSP) without (too much of) the formalism usually associated with the topic. Of course, to get a deep understanding of how this works and what sort of things you can really do with DSP you\u2019ll probably have to learn the math…<\/p>\n","protected":false},"author":206,"featured_media":508,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"image","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-465","post","type-post","status-publish","format-image","has-post-thumbnail","hentry","category-uncategorized","post_format-post-format-image"],"jetpack_featured_media_url":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-content\/uploads\/sites\/89\/2018\/09\/sin2.png","_links":{"self":[{"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/posts\/465","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/users\/206"}],"replies":[{"embeddable":true,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/comments?post=465"}],"version-history":[{"count":35,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/posts\/465\/revisions"}],"predecessor-version":[{"id":518,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/posts\/465\/revisions\/518"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/media\/508"}],"wp:attachment":[{"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/media?parent=465"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/categories?post=465"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wordpress.cs.vt.edu\/ccs2018f\/wp-json\/wp\/v2\/tags?post=465"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}