diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 0000000000..812fc3b139 --- /dev/null +++ b/.coveragerc @@ -0,0 +1,4 @@ +[report] +omit = + */python?.?/* + */site-packages/nose/* diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000..6141594332 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +tests/data/*.mat export-ignore diff --git a/.gitignore b/.gitignore index 897f99b37f..c49fce71eb 100644 --- a/.gitignore +++ b/.gitignore @@ -19,6 +19,7 @@ pip-log.txt # Unit test / coverage reports .coverage .tox +tests/result_images/ #Translations *.mo @@ -29,3 +30,19 @@ pip-log.txt # Data files */data/* *.mat + +# Mac OS X cruft +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +# Sphinx stuff +docs/generated/ +docs/_build/ + +# Vim +*.swp diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000000..28af3bb7a7 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,42 @@ +sudo: false + +addons: + apt: + packages: + - ffmpeg + +cache: + directories: + - $HOME/env + +language: python + +notifications: + email: false + +python: + - "2.7" + - "3.4" + - "3.5" + +before_install: + - bash .travis_dependencies.sh + - export PATH="$HOME/env/miniconda$TRAVIS_PYTHON_VERSION/bin:$PATH"; + - hash -r + - source activate test-environment + +install: + # install your own package into the environment + # pip install -e rather than setup.py, so that coverage can find the source + - pip install -e ./ + +script: + - python --version + - nosetests --with-coverage --cover-erase --cover-package=librosa -v -w tests/ + +after_success: + - coveralls + - pip uninstall -y librosa + +after_failure: + - pip uninstall -y librosa diff --git a/.travis_dependencies.sh b/.travis_dependencies.sh new file mode 100644 index 0000000000..e1a5552923 --- /dev/null +++ b/.travis_dependencies.sh @@ -0,0 +1,50 @@ +#!/bin/sh + +ENV_NAME="test-environment" +set -e + +conda_create () +{ + + hash -r + conda config --set always_yes yes --set changeps1 no + conda update -q conda + conda config --add channels pypi + conda info -a + deps='pip numpy scipy pandas requests nose coverage numpydoc matplotlib sphinx scikit-learn seaborn' + + conda create -q -n $ENV_NAME "python=$TRAVIS_PYTHON_VERSION" $deps + conda update --all +} + +src="$HOME/env/miniconda$TRAVIS_PYTHON_VERSION" +if [ ! -d "$src" ]; then + mkdir -p $HOME/env + pushd $HOME/env + + # Download miniconda packages + wget http://repo.continuum.io/miniconda/Miniconda-3.16.0-Linux-x86_64.sh -O miniconda.sh; + # Install libsamplerate + apt-get source libsamplerate + + # Install both environments + bash miniconda.sh -b -p $src + + export PATH="$src/bin:$PATH" + conda_create + + pushd libsamplerate-* + ./configure --prefix=$src/envs/$ENV_NAME + make && make install + popd + + source activate $ENV_NAME + + pip install git+https://github.com/bmcfee/samplerate.git + pip install python-coveralls + + source deactivate + popd +else + echo "Using cached dependencies" +fi diff --git a/AUTHORS.md b/AUTHORS.md new file mode 100644 index 0000000000..3e6b12fbd8 --- /dev/null +++ b/AUTHORS.md @@ -0,0 +1,25 @@ +Contributors +============ + +* Brian McFee +* Matt McVicar +* Dawen Liang +* Colin Raffel +* Douglas Repetto +* Dan Ellis +* Eric Battenberg +* Bryce Walburn +* Oriol Nieto +* Romain Hennequin +* Ryuichi Yamamoto +* Rachel Bittner +* Stefan Balke + +Some feature extraction code was based on by Ron Weiss. + +Large portions of LibROSA were ported from MATLAB code by Dan Ellis . + +Some spectral features were ported from original MATLAB implementations by Erik Schmidt and Jeff Scott +at the Drexel METlab + +Additional thanks to Emanuele Coviello and Erik Schmidt for testing, bug reports and fixes. diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000000..7fd4860124 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,326 @@ +Changes +======= + +##v0.4.2 + +Bug fixes + - Support for matplotlib 1.5 color properties in the `display` module + - [#308] Fixed a per-octave scaling error in `librosa.cqt` + +New features + - [#279] `librosa.cqt` now provides complex-valued output with argument `real=False`. + This will become the default behavior in subsequent releases. + - [#288] `core.resample` now supports multi-channel inputs + - [#295] `librosa.display.frequency_ticks`: like `time_ticks`. Ticks can now dynamically + adapt to scale (mHz, Hz, KHz, MHz, GHz) and use automatic precision formatting (`%g`) + + +Other changes + - [#277] improved documentation + - [#294] deprecated the `FeatureExtractor` object + - [#300] added dependency version requirements to install script + - [#302], [#279] renamed the following parameters + - `librosa.display.time_ticks`: `fmt` is now `time_fmt` + - `librosa.feature.chroma_cqt`: `mode` is now `cqt_mode` + - `librosa.cqt`, `hybrid_cqt`, `pseudo_cqt`, `librosa.filters.constant_q`: `resolution` is now `filter_scale` + - [#308] `librosa.cqt` default `filter_scale` parameter is now 1 instead of 2. + +[#277]: https://github.com/bmcfee/librosa/pull/277 +[#279]: https://github.com/bmcfee/librosa/pull/279 +[#288]: https://github.com/bmcfee/librosa/pull/288 +[#294]: https://github.com/bmcfee/librosa/pull/294 +[#295]: https://github.com/bmcfee/librosa/pull/295 +[#300]: https://github.com/bmcfee/librosa/pull/300 +[#302]: https://github.com/bmcfee/librosa/pull/302 +[#308]: https://github.com/bmcfee/librosa/pull/308 + +##v0.4.1 + +Bug fixes + - Improved safety check in CQT for invalid hop lengths + - Fixed division by zero bug in `core.pitch.pip_track` + - Fixed integer-type error in `util.pad_center` on numpy v1.10 + - Fixed a context scoping error in `librosa.load` with some audioread backends + - `librosa.autocorrelate` now persists type for complex input + +New features + - `librosa.clicks` sonifies timed events such as beats or onsets + - `librosa.onset.onset_strength_multi` computes onset strength within multiple sub-bands + - `librosa.feature.tempogram` computes localized onset strength autocorrelation + - `librosa.display.specshow` now supports `*_axis='tempo'` for annotating tempo-scaled data + - `librosa.fmt` implements the Fast Mellin Transform + +Other changes + + - Rewrote `display.waveplot` for improved efficiency + - `decompose.deompose()` now supports pre-trained transformation objects + - Nullified side-effects of optional seaborn dependency + - Moved `feature.sync` to `util.sync` and expanded its functionality + - `librosa.onset.onset_strength` and `onset_strength_multi` support superflux-style lag and max-filtering + - `librosa.core.autocorrelate` can now operate along any axis of multi-dimensional input + - the `segment` module functions now support arbitrary target axis + - Added proper window normalization to `librosa.core.istft` for better reconstruction ([#235]). + - Standardized `n_fft=2048` for `piptrack`, `ifptrack` (deprecated), and `logfsgram` (deprecated) + - `onset_strength` parameter `'centering'` has been deprecated and renamed to `'center'` + - `onset_strength` always trims to match the input spectrogram duration + - added tests for `piptrack` + - added test support for Python 3.5 + +[#235]: https://github.com/bmcfee/librosa/pull/235 + +##v0.4.0 + +Bug fixes + + - Fixed alignment errors with `offset` and `duration` in `load()` + - Fixed an edge-padding issue with `decompose.hpss()` which resulted in + percussive noise leaking into the harmonic component. + - Fixed stability issues with `ifgram()`, added options to suppress negative frequencies. + - Fixed scaling and padding errors in `feature.delta()` + - Fixed some errors in `note_to_hz()` string parsing + - Added robust range detection for `display.cmap` + - Fixed tick placement in `display.specshow` + - Fixed a low-frequency filter alignment error in `cqt` + - Added aliasing checks for `cqt` filterbanks + - Fixed corner cases in `peak_pick` + - Fixed bugs in `find_files()` with negative slicing + - Fixed tuning estimation errors + - Fixed octave numbering in to conform to scientific pitch notation + +New features + + - python 3 compatibility + - Deprecation and moved-function warnings + - added `norm=None` option to `util.normalize()` + - `segment.recurrence_to_lag`, `lag_to_recurrence` + - `core.hybrid_cqt()` and `core.pseudo_cqt()` + - `segment.timelag_filter` + - Efficiency enhancements for `cqt` + - Major rewrite and reformatting of documentation + - Improvements to `display.specshow`: + - added the `lag` axis format + - added the `tonnetz` axis format + - allow any combination of axis formats + - `effects.remix()` + - Added new time and frequency converters: + - `note_to_hz()`, `hz_to_note()` + - `frames_to_samples()`, `samples_to_frames()` + - `time_to_samples()`, `samples_to_time()` + - `core.zero_crossings` + - `util.match_events()` + - `segment.subsegment()` for segmentation refinement + - Functional examples in almost all docstrings + - improved numerical stability in `normalize()` + - audio validation checks + - `to_mono()` + - `librosa.cache` for storing pre-computed features + - Stereo output support in `write_wav` + - Added new feature extraction functions: + - `feature.spectral_contrast` + - `feature.spectral_bandwidth` + - `feature.spectral_centroid` + - `feature.spectral_rolloff` + - `feature.poly_features` + - `feature.rmse` + - `feature.zero_crossing_rate` + - `feature.tonnetz` + - Added `librosa.display.waveplot` + + +Other changes + - Internal refactoring and restructuring of submodules + - Removed the `chord` module + - input validation and better exception reporting for most functions + - Changed the default colormaps in `display` + - Changed default parameters in onset detection, beat tracking + - Changed default parameters in `cqt` + - `filters.constant_q` now returns filter lengths + - Chroma now starts at `C` by default, instead of `A` + - `pad_center` supports multi-dimensional input and `axis` parameter + - switched from `np.fft` to `scipy.fftpack` for FFT operations + - changed all librosa-generated exception to a new class librosa.ParameterError + +Deprecated functions + + - `util.buf_to_int` + - `output.frames_csv` + - `segment.structure_feature` + - `filters.logfrequency` + - `feature.logfsgram` + + +##v0.3.1 + +Bug fixes + + - Fixed bug #117: `librosa.segment.agglomerative` now returns a numpy.ndarray instead of a list + - Fixed bug #115: off-by-one error in `librosa.core.load` with fixed duration + - Fixed numerical underflow errors in `librosa.decompose.hpss` + - Fixed bug #104: `librosa.decompose.hpss` failed with silent, complex-valued input + - Fixed bug #103: `librosa.feature.estimate_tuning` fails when no bins exceed the threshold + +Features + + - New function `librosa.core.get_duration()` computes the duration of an audio signal + or spectrogram-like input matrix + - `librosa.util.pad_center` now accepts multi-dimensional input + +Other changes + + - Adopted the ISC license + - Python 3 compatibility via futurize + - Fixed issue #102: segment.agglomerative no longer depends on the deprecated + Ward module of sklearn; it now depends on the newer Agglomerative module. + - Issue #108: set character encoding on all source files + - Added dtype persistence for resample, stft, istft, and effects functions + +##v0.3.0 + +Bug fixes + + - Fixed numpy array indices to force integer values + - `librosa.util.frame` now warns if the input data is non-contiguous + - Fixed a formatting error in `librosa.display.time_ticks()` + - Added a warning if `scikits.samplerate` is not detected + +Features + + - New module `librosa.chord` for training chord recognition models + - Parabolic interpolation piptracking `librosa.feature.piptrack()` + - `librosa.localmax()` now supports multi-dimensional slicing + - New example scripts + - Improved documentation + - Added the `librosa.util.FeatureExtractor` class, which allows librosa functions + to act as feature extraction stages in `sklearn` + - New module `librosa.effects` for time-domain audio processing + - Added demo notebooks for the `librosa.effects` and `librosa.util.FeatureExtractor` + - Added a full-track audio example, `librosa.util.example_audio_file()` + - Added peak-frequency sorting of basis elements in `librosa.decompose.decompose()` + +Other changes + + - Spectrogram frames are now centered, rather than left-aligned. This removes the + need for window correction in `librosa.frames_to_time()` + - Accelerated constant-Q transform `librosa.cqt()` + - PEP8 compliance + - Removed normalization from `librosa.feature.logfsgram()` + - Efficiency improvements by ensuring memory contiguity + - `librosa.logamplitude()` now supports functional reference power, in addition + to scalar values + - Improved `librosa.feature.delta()` + - Additional padding options to `librosa.feature.stack_memory()` + - `librosa.cqt` and `librosa.feature.logfsgram` now use the same parameter + formats `(fmin, n_bins, bins_per_octave)`. + - Updated demo notebook(s) to IPython 2.0 + - Moved `perceptual_weighting()` from `librosa.feature` into `librosa.core` + - Moved `stack_memory()` from `librosa.segment` into `librosa.feature` + - Standardized `librosa.output.annotation` input format to match `mir_eval` + - Standardized variable names (e.g., `onset_envelope`). + +##v0.2.1 + +Bug fixes + + - fixed an off-by-one error in `librosa.onset.onset_strength()` + - fixed a sign-flip error in `librosa.output.write_wav()` + - removed all mutable object default parameters + +Features + + - added option `centering` to `librosa.onset.onset_strength()` to resolve frame-centering issues with sliding window STFT + - added frame-center correction to `librosa.core.frames_to_time()` and `librosa.core.time_to_frames()` + - added `librosa.util.pad_center()` + - added `librosa.output.annotation()` + - added `librosa.output.times_csv()` + - accelerated `librosa.core.stft()` and `ifgram()` + - added `librosa.util.frame` for in-place signal framing + - `librosa.beat.beat_track` now supports user-supplied tempo + - added `librosa.util.normalize()` + - added `librosa.util.find_files()` + - added `librosa.util.axis_sort()` + - new module: `librosa.util()` + - `librosa.filters.constant_q` now support padding + - added boolean input support for `librosa.display.cmap()` + - speedup in `librosa.core.cqt()` + +Other changes + + - optimized default parameters for `librosa.onset.onset_detect` + - set `librosa.filters.mel` parameter `n_mels=128` by default + - `librosa.feature.chromagram()` and `logfsgram()` now use power instead of energy + - `librosa.display.specshow()` with `y_axis='chroma'` now labels as `pitch class` + - set `librosa.core.cqt` parameter `resolution=2` by default + - set `librosa.feature.chromagram` parameter `octwidth=2` by default + +## v0.2.0 + +Bug fixes + + - fixed default `librosa.core.stft, istft, ifgram` to match specification + - fixed a float->int bug in peak_pick + - better memory efficiency + - `librosa.segment.recurrence_matrix` corrects for width suppression + - fixed a divide-by-0 error in the beat tracker + - fixed a bug in tempo estimation with short windows + - `librosa.feature.sync` now supports 1d arrays + - fixed a bug in beat trimming + - fixed a bug in `librosa.core.stft` when calculating window size + - fixed `librosa.core.resample` to support stereo signals + +Features + + - added filters option to cqt + - added window function support to istft + - added an IPython notebook demo + - added `librosa.features.delta` for computing temporal difference features + - new `examples` scripts: tuning, hpss + - added optional trimming to `librosa.segment.stack_memory` + - `librosa.onset.onset_strength` now takes generic spectrogram function `feature` + - compute reference power directly in `librosa.core.logamplitude` + - color-blind-friendly default color maps in `librosa.display.cmap` + - `librosa.core.onset_strength` now accepts an aggregator + - added `librosa.feature.perceptual_weighting` + - added tuning estimation to `librosa.feature.chromagram` + - added `librosa.core.A_weighting` + - vectorized frequency converters + - added `librosa.core.cqt_frequencies` to get CQT frequencies + - `librosa.core.cqt` basic constant-Q transform implementation + - `librosa.filters.cq_to_chroma` to convert log-frequency to chroma + - added `librosa.core.fft_frequencies` + - `librosa.decompose.hpss` can now return masking matrices + - added reversal for `librosa.segment.structure_feature` + - added `librosa.core.time_to_frames` + - added cent notation to `librosa.core.midi_to_note` + - added time-series or spectrogram input options to `chromagram`, `logfsgram`, `melspectrogram`, and `mfcc` + - new module: `librosa.display` + - `librosa.output.segment_csv` => `librosa.output.frames_csv` + - migrated frequency converters to `librosa.core` + - new module: `librosa.filters` + - `librosa.decompose.hpss` now supports complex-valued STFT matrices + - `librosa.decompose.decompose()` supports `sklearn` decomposition objects + - added `librosa.core.phase_vocoder` + - new module: `librosa.onset`; migrated onset strength from `librosa.beat` + - added `librosa.core.pick_peaks` + - `librosa.core.load()` supports offset and duration parameters + - `librosa.core.magphase()` to separate magnitude and phase from a complex matrix + - new module: `librosa.segment` + +Other changes + + - `onset_estimate_bpm => estimate_tempo` + - removed `n_fft` from `librosa.core.istft()` + - `librosa.core.mel_frequencies` returns `n_mels` values by default + - changed default `librosa.decompose.hpss` window to 31 + - disabled onset de-trending by default in `librosa.onset.onset_strength` + - added complex-value warning to `librosa.display.specshow` + - broke compatibilty with `ifgram.m`; `librosa.core.ifgram` now matches `stft` + - changed default beat tracker settings + - migrated `hpss` into `librosa.decompose` + - changed default `librosa.decompose.hpss` power parameter to `2.0` + - `librosa.core.load()` now returns single-precision by default + - standardized `n_fft=2048`, `hop_length=512` for most functions + - refactored tempo estimator + +## v0.1.0 + +Initial public release. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000000..8391bed418 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,89 @@ + +Contributing code +================= + +How to contribute +----------------- + +The preferred way to contribute to librosa is to fork the +[main repository](http://github.com/bmcfee/librosa/) on +GitHub: + +1. Fork the [project repository](http://github.com/bmcfee/librosa): + click on the 'Fork' button near the top of the page. This creates + a copy of the code under your account on the GitHub server. + +2. Clone this copy to your local disk: + + $ git clone git@github.com:YourLogin/librosa.git + $ cd librosa + +3. Create a branch to hold your changes: + + $ git checkout -b my-feature + + and start making changes. Never work in the ``master`` branch! + +4. Work on this copy on your computer using Git to do the version + control. When you're done editing, do: + + $ git add modified_files + $ git commit + + to record your changes in Git, then push them to GitHub with: + + $ git push -u origin my-feature + +Finally, go to the web page of the your fork of the librosa repo, +and click 'Pull request' to send your changes to the maintainers for +review. This will send an email to the committers. + +(If any of the above seems like magic to you, then look up the +[Git documentation](http://git-scm.com/documentation) on the web.) + +It is recommended to check that your contribution complies with the +following rules before submitting a pull request: + +- All public methods should have informative docstrings with sample + usage presented. + +You can also check for common programming errors with the following +tools: + +- Code with good unittest coverage (at least 80%), check with: + + $ pip install nose coverage + $ nosetests --with-coverage --cover-package=librosa -w tests/ + +- No pyflakes warnings, check with: + + $ pip install pyflakes + $ pyflakes path/to/module.py + +- No PEP8 warnings, check with: + + $ pip install pep8 + $ pep8 path/to/module.py + +- AutoPEP8 can help you fix some of the easy redundant errors: + + $ pip install autopep8 + $ autopep8 path/to/pep8.py + + +Documentation +------------- + +You can edit the documentation using any text editor and then generate +the HTML output by typing ``make html`` from the docs/ directory. +The resulting HTML files will be placed in _build/html/ and are viewable +in a web browser. See the README file in the doc/ directory for more information. + +For building the documentation, you will need +[sphinx](http://sphinx.pocoo.org/), +[matplotlib](http://matplotlib.sourceforge.net/), and [scikit-learn](http://scikit-learn.org/). + + +Note +---- +This document was gleefully borrowed from [scikit-learn](http://scikit-learn.org/). diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000000..49f5772fff --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,13 @@ +Copyright (c) 2016, librosa development team. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/README.md b/README.md index ff7e8d4bc4..45c6a7b8f3 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,77 @@ librosa ======= +A python package for music and audio analysis. -A python module for music and audio processing. +[![PyPI](https://img.shields.io/pypi/v/librosa.svg)](https://pypi.python.org/pypi/librosa) +[![License](https://img.shields.io/pypi/l/librosa.svg)](https://github.com/bmcfee/librosa/blob/master/LICENSE.md) +[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.32193.svg)](http://dx.doi.org/10.5281/zenodo.32193) -Mostly ports and reimplementations of DPWE's matlab code. +[![Build Status](https://travis-ci.org/bmcfee/librosa.png?branch=master)](http://travis-ci.org/bmcfee/librosa?branch=master) +[![Coverage Status](https://coveralls.io/repos/bmcfee/librosa/badge.svg?branch=master)](https://coveralls.io/r/bmcfee/librosa?branch=master) -* librosa/ The librosa module -* examples/ Some basic examples of audio processing with librosa +Documentation +------------- +See http://bmcfee.github.io/librosa/ for a complete reference manual and introductory tutorials. -* tests/ nose unit tests to validate against original dpwe implementations + +Demonstration notebooks +----------------------- +What does librosa do? Here are some quick demonstrations: + +* [Introduction notebook](http://nbviewer.ipython.org/github/bmcfee/librosa/blob/master/examples/LibROSA%20demo.ipynb): a brief introduction to some commonly used features. +* [Decomposition and IPython integration](http://nbviewer.ipython.org/github/bmcfee/librosa/blob/master/examples/LibROSA%20audio%20effects%20and%20playback.ipynb): an intermediate demonstration, illustrating how to process and play back sound + + +Installation +------------ + +The latest stable release is available on PyPI, and you can install it by saying +``` +pip install librosa +``` + +To build librosa from source, say `python setup.py build`. +Then, to install librosa, say `python setup.py install`. +If all went well, you should be able to execute the demo scripts under `examples/` +(OS X users should follow the installation guide given below). + +Alternatively, you can download or clone the repository and use `pip` to handle dependencies: + +``` +unzip librosa.zip +pip install -e librosa +``` +or +``` +git clone https://github.com/bmcfee/librosa.git +pip install -e librosa +``` + +By calling `pip list` you should see `librosa` now as an installed pacakge: +``` +librosa (0.x.x, /path/to/librosa) +``` + +### Hints for OS X + +#### ffmpeg + +To fuel `audioread` with more audio-decoding power, you can install *ffmpeg* which +ships with many audio decoders. + +You can use *homebrew* to install the programm by calling +`brew install ffmpeg` or get a binary version from their website https://www.ffmpeg.org. + +Discussion +---------- + +Please direct non-development questions and discussion topics to our web forum at +https://groups.google.com/forum/#!forum/librosa + + +Citing +------ + +Please refer to the Zenodo link below for citation information. +[![DOI](https://zenodo.org/badge/doi/10.5281/zenodo.32193.svg)](http://dx.doi.org/10.5281/zenodo.32193) diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000000..226cf8da88 --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,153 @@ +# Makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +PAPER = +BUILDDIR = _build + +# Internal variables. +PAPEROPT_a4 = -D latex_paper_size=a4 +PAPEROPT_letter = -D latex_paper_size=letter +ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . +# the i18n builder cannot share the environment and doctrees with the others +I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . + +.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext + +help: + @echo "Please use \`make ' where is one of" + @echo " html to make standalone HTML files" + @echo " dirhtml to make HTML files named index.html in directories" + @echo " singlehtml to make a single large HTML file" + @echo " pickle to make pickle files" + @echo " json to make JSON files" + @echo " htmlhelp to make HTML files and a HTML help project" + @echo " qthelp to make HTML files and a qthelp project" + @echo " devhelp to make HTML files and a Devhelp project" + @echo " epub to make an epub" + @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" + @echo " latexpdf to make LaTeX files and run them through pdflatex" + @echo " text to make text files" + @echo " man to make manual pages" + @echo " texinfo to make Texinfo files" + @echo " info to make Texinfo files and run them through makeinfo" + @echo " gettext to make PO message catalogs" + @echo " changes to make an overview of all changed/added/deprecated items" + @echo " linkcheck to check all external links for integrity" + @echo " doctest to run all doctests embedded in the documentation (if enabled)" + +clean: + -rm -rf $(BUILDDIR)/* + +html: + $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." + +dirhtml: + $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." + +singlehtml: + $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml + @echo + @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." + +pickle: + $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle + @echo + @echo "Build finished; now you can process the pickle files." + +json: + $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json + @echo + @echo "Build finished; now you can process the JSON files." + +htmlhelp: + $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp + @echo + @echo "Build finished; now you can run HTML Help Workshop with the" \ + ".hhp project file in $(BUILDDIR)/htmlhelp." + +qthelp: + $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp + @echo + @echo "Build finished; now you can run "qcollectiongenerator" with the" \ + ".qhcp project file in $(BUILDDIR)/qthelp, like this:" + @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/librosa.qhcp" + @echo "To view the help file:" + @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/librosa.qhc" + +devhelp: + $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp + @echo + @echo "Build finished." + @echo "To view the help file:" + @echo "# mkdir -p $$HOME/.local/share/devhelp/librosa" + @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/librosa" + @echo "# devhelp" + +epub: + $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub + @echo + @echo "Build finished. The epub file is in $(BUILDDIR)/epub." + +latex: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo + @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." + @echo "Run \`make' in that directory to run these through (pdf)latex" \ + "(use \`make latexpdf' here to do that automatically)." + +latexpdf: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through pdflatex..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +text: + $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text + @echo + @echo "Build finished. The text files are in $(BUILDDIR)/text." + +man: + $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man + @echo + @echo "Build finished. The manual pages are in $(BUILDDIR)/man." + +texinfo: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo + @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." + @echo "Run \`make' in that directory to run these through makeinfo" \ + "(use \`make info' here to do that automatically)." + +info: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo "Running Texinfo files through makeinfo..." + make -C $(BUILDDIR)/texinfo info + @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." + +gettext: + $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale + @echo + @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." + +changes: + $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes + @echo + @echo "The overview file is in $(BUILDDIR)/changes." + +linkcheck: + $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck + @echo + @echo "Link check complete; look for any errors in the above output " \ + "or in $(BUILDDIR)/linkcheck/output.txt." + +doctest: + $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest + @echo "Testing of doctests in the sources finished, look at the " \ + "results in $(BUILDDIR)/doctest/output.txt." diff --git a/docs/_build/.nojekyll b/docs/_build/.nojekyll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/docs/beat.rst b/docs/beat.rst new file mode 100644 index 0000000000..12bc95be7f --- /dev/null +++ b/docs/beat.rst @@ -0,0 +1,4 @@ +.. _beat: + +.. automodule:: librosa.beat + diff --git a/docs/cache.rst b/docs/cache.rst new file mode 100644 index 0000000000..a1496940aa --- /dev/null +++ b/docs/cache.rst @@ -0,0 +1,97 @@ +Caching +======= + +This section covers the *librosa* function cache. This allows you +to store and re-use intermediate computations across sessions. + +Enabling the cache +------------------ +By default, caching is disabled. To enable caching, the environment +variable `LIBROSA_CACHE_DIR` must be set prior to loading *librosa*. +This can be done on the command line prior to instantiating a python interpreter:: + + $ export LIBROSA_CACHE_DIR=/tmp/librosa_cache + $ ipython + +or from within python, prior to importing *librosa*:: + + >>> import os + >>> os.environ['LIBROSA_CACHE_DIR'] = '/tmp/librosa_cache' + >>> import librosa + +.. warning:: + The cache does not implement any eviction policy. As such, + it can grow without bound on disk if not purged. + To purge the cache directly, call:: + + >>> librosa.cache.clear() + + + +Cache configuration +------------------- +The cache is implemented on top of `joblib.Memory `_. +The default configuration can be overridden by setting the following environment variables + + - `LIBROSA_CACHE_DIR` : path (on disk) to the cache directory + - `LIBROSA_CACHE_MMAP` : optional memory mapping mode `{None, 'r+', 'r', 'w+', 'c'}` + - `LIBROSA_CACHE_COMPRESS` : flag to enable compression of data on disk `{0, 1}` + - `LIBROSA_CACHE_VERBOSE` : controls how much debug info is displayed. `{int, non-negative}` + +Please refer to the `joblib.Memory` `documentation +`_ for a detailed explanation of these +parameters. + +Example +------- +To demonstrate how to use the cache, we'll first call an example script twice without caching:: + + [~/git/librosa/examples]$ time ./estimate_tuning.py ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Loading ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Separating harmonic component ... + Estimating tuning ... + +6.00 cents + + real 0m4.369s + user 0m4.065s + sys 0m0.350s + + [~/git/librosa/examples]$ time ./estimate_tuning.py ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Loading ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Separating harmonic component ... + Estimating tuning ... + +6.00 cents + + real 0m4.414s + user 0m4.013s + sys 0m0.440s + + +Next, we'll enable caching to `/tmp/librosa`:: + + [~/git/librosa/examples]$ export LIBROSA_CACHE_DIR=/tmp/librosa + +And now we'll re-run the example script twice. The first time, there will be no cached values, so the time +should be similar to running without cache. The second time, we'll be able to reuse intermediate values, so +it should be significantly faster.:: + + [~/git/librosa/examples]$ time ./estimate_tuning.py ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Loading ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Separating harmonic component ... + Estimating tuning ... + +6.00 cents + + real 0m4.859s + user 0m4.471s + sys 0m0.429s + + [~/git/librosa/examples]$ time ./estimate_tuning.py ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Loading ../librosa/example_data/Kevin_MacLeod_-_Vibe_Ace.mp3 + Separating harmonic component ... + Estimating tuning ... + +6.00 cents + + real 0m0.931s + user 0m0.862s + sys 0m0.112s + diff --git a/docs/changelog.rst b/docs/changelog.rst new file mode 100644 index 0000000000..9dfc6ae606 --- /dev/null +++ b/docs/changelog.rst @@ -0,0 +1,378 @@ +Changes +======= + +v0.4.2 +------ + +Bug fixes + - Support for matplotlib 1.5 color properties in the ``display`` module + - `#308`_ Fixed a per-octave scaling error in ``librosa.cqt`` + +New features + - `#279`_ ``librosa.cqt`` now provides complex-valued output with argument `real=False`. + This will become the default behavior in subsequent releases. + - `#288`_ ``core.resample`` now supports multi-channel inputs + - `#295`_ ``librosa.display.frequency_ticks``: like ``time_ticks``. Ticks can now dynamically + adapt to scale (mHz, Hz, KHz, MHz, GHz) and use automatic precision formatting (``%g``) + + +Other changes + - `#277`_ improved documentation + - `#294`_ deprecated the ``FeatureExtractor`` object + - `#300`_ added dependency version requirements to install script + - `#302`_, `#279`_ renamed the following parameters + - ``librosa.display.time_ticks``: `fmt` is now `time_fmt` + - ``librosa.feature.chroma_cqt``: `mode` is now `cqt_mode` + - ``librosa.cqt``, ``hybrid_cqt``, ``pseudo_cqt``, ``librosa.filters.constant_q``: `resolution` is now `filter_scale` + - `#308`_ ``librosa.cqt`` default `filter_scale` parameter is now 1 instead of 2. + +.. _#277: https://github.com/bmcfee/librosa/pull/277 +.. _#279: https://github.com/bmcfee/librosa/pull/279 +.. _#288: https://github.com/bmcfee/librosa/pull/288 +.. _#294: https://github.com/bmcfee/librosa/pull/294 +.. _#295: https://github.com/bmcfee/librosa/pull/295 +.. _#300: https://github.com/bmcfee/librosa/pull/300 +.. _#302: https://github.com/bmcfee/librosa/pull/302 +.. _#308: https://github.com/bmcfee/librosa/pull/308 + +v0.4.1 +------ + +Bug fixes + - Improved safety check in CQT for invalid hop lengths + - Fixed division by zero bug in ``core.pitch.pip_track`` + - Fixed integer-type error in ``util.pad_center`` on numpy v1.10 + - Fixed a context scoping error in ``librosa.load`` with some audioread backends + - ``librosa.autocorrelate`` now persists type for complex input + +New features + - ``librosa.clicks`` sonifies timed events such as beats or onsets + - ``librosa.onset.onset_strength_multi`` computes onset strength within multiple sub-bands + - ``librosa.feature.tempogram`` computes localized onset strength autocorrelation + - ``librosa.display.specshow`` now supports ``*_axis='tempo'`` for annotating tempo-scaled data + - ``librosa.fmt`` implements the Fast Mellin Transform + +Other changes + + - Rewrote ``display.waveplot`` for improved efficiency + - ``decompose.deompose()`` now supports pre-trained transformation objects + - Nullified side-effects of optional seaborn dependency + - Moved ``feature.sync`` to ``util.sync`` and expanded its functionality + - ``librosa.onset.onset_strength`` and ``onset_strength_multi`` support superflux-style lag and max-filtering + - ``librosa.core.autocorrelate`` can now operate along any axis of multi-dimensional input + - the ``segment`` module functions now support arbitrary target axis + - Added proper window normalization to ``librosa.core.istft`` for better reconstruction + (`PR #235 `_). + - Standardized ``n_fft=2048`` for ``piptrack``, ``ifptrack`` (deprecated), and + ``logfsgram`` (deprecated) + - ``onset_strength`` parameter ``'centering'`` has been deprecated and renamed to + ``'center'`` + - ``onset_strength`` always trims to match the input spectrogram duration + - added tests for ``piptrack`` + - added test support for Python 3.5 + + + + +v0.4.0 +------ + +Bug fixes + +- Fixed alignment errors with ``offset`` and ``duration`` in ``load()`` +- Fixed an edge-padding issue with ``decompose.hpss()`` which resulted + in + percussive noise leaking into the harmonic component. +- Fixed stability issues with ``ifgram()``, added options to suppress + negative frequencies. +- Fixed scaling and padding errors in ``feature.delta()`` +- Fixed some errors in ``note_to_hz()`` string parsing +- Added robust range detection for ``display.cmap`` +- Fixed tick placement in ``display.specshow`` +- Fixed a low-frequency filter alignment error in ``cqt`` +- Added aliasing checks for ``cqt`` filterbanks +- Fixed corner cases in ``peak_pick`` +- Fixed bugs in ``find_files()`` with negative slicing +- Fixed tuning estimation errors +- Fixed octave numbering in to conform to scientific pitch notation + +New features + +- python 3 compatibility +- Deprecation and moved-function warnings +- added ``norm=None`` option to ``util.normalize()`` +- ``segment.recurrence_to_lag``, ``lag_to_recurrence`` +- ``core.hybrid_cqt()`` and ``core.pseudo_cqt()`` +- ``segment.timelag_filter`` +- Efficiency enhancements for ``cqt`` +- Major rewrite and reformatting of documentation +- Improvements to ``display.specshow``: + + - added the ``lag`` axis format + - added the ``tonnetz`` axis format + - allow any combination of axis formats + +- ``effects.remix()`` +- Added new time and frequency converters: + + - ``note_to_hz()``, ``hz_to_note()`` + - ``frames_to_samples()``, ``samples_to_frames()`` + - ``time_to_samples()``, ``samples_to_time()`` + +- ``core.zero_crossings`` +- ``util.match_events()`` +- ``segment.subsegment()`` for segmentation refinement +- Functional examples in almost all docstrings +- improved numerical stability in ``normalize()`` +- audio validation checks +- ``to_mono()`` +- ``librosa.cache`` for storing pre-computed features +- Stereo output support in ``write_wav`` +- Added new feature extraction functions: + + - ``feature.spectral_contrast`` + - ``feature.spectral_bandwidth`` + - ``feature.spectral_centroid`` + - ``feature.spectral_rolloff`` + - ``feature.poly_features`` + - ``feature.rmse`` + - ``feature.zero_crossing_rate`` + - ``feature.tonnetz`` + +- Added ``display.waveplot`` + +Other changes + +- Internal refactoring and restructuring of submodules +- Removed the ``chord`` module +- input validation and better exception reporting for most functions +- Changed the default colormaps in ``display`` +- Changed default parameters in onset detection, beat tracking +- Changed default parameters in ``cqt`` +- ``filters.constant_q`` now returns filter lengths +- Chroma now starts at ``C`` by default, instead of ``A`` +- ``pad_center`` supports multi-dimensional input and ``axis`` + parameter +- switched from ``np.fft`` to ``scipy.fftpack`` for FFT operations +- changed all librosa-generated exception to a new class librosa.ParameterError + +Deprecated functions + +- ``util.buf_to_int`` +- ``output.frames_csv`` +- ``segment.structure_feature`` +- ``filters.logfrequency`` +- ``feature.logfsgram`` + +v0.3.1 +------ + +Bug fixes + +- Fixed bug #117: ``librosa.segment.agglomerative`` now returns a + numpy.ndarray instead of a list +- Fixed bug #115: off-by-one error in ``librosa.core.load`` with fixed + duration +- Fixed numerical underflow errors in ``librosa.decompose.hpss`` +- Fixed bug #104: ``librosa.decompose.hpss`` failed with silent, + complex-valued input +- Fixed bug #103: ``librosa.feature.estimate_tuning`` fails when no + bins exceed the threshold + +Features + +- New function ``librosa.core.get_duration()`` computes the duration of + an audio signal + or spectrogram-like input matrix +- ``librosa.util.pad_center`` now accepts multi-dimensional input + +Other changes + +- Adopted the ISC license +- Python 3 compatibility via futurize +- Fixed issue #102: segment.agglomerative no longer depends on the + deprecated + Ward module of sklearn; it now depends on the newer Agglomerative + module. +- Issue #108: set character encoding on all source files +- Added dtype persistence for resample, stft, istft, and effects + functions + +v0.3.0 +------ + +Bug fixes + +- Fixed numpy array indices to force integer values +- ``librosa.util.frame`` now warns if the input data is non-contiguous +- Fixed a formatting error in ``librosa.display.time_ticks()`` +- Added a warning if ``scikits.samplerate`` is not detected + +Features + +- New module ``librosa.chord`` for training chord recognition models +- Parabolic interpolation piptracking ``librosa.feature.piptrack()`` +- ``librosa.localmax()`` now supports multi-dimensional slicing +- New example scripts +- Improved documentation +- Added the ``librosa.util.FeatureExtractor`` class, which allows + librosa functions + to act as feature extraction stages in ``sklearn`` +- New module ``librosa.effects`` for time-domain audio processing +- Added demo notebooks for the ``librosa.effects`` and + ``librosa.util.FeatureExtractor`` +- Added a full-track audio example, + ``librosa.util.example_audio_file()`` +- Added peak-frequency sorting of basis elements in + ``librosa.decompose.decompose()`` + +Other changes + +- Spectrogram frames are now centered, rather than left-aligned. This + removes the + need for window correction in ``librosa.frames_to_time()`` +- Accelerated constant-Q transform ``librosa.cqt()`` +- PEP8 compliance +- Removed normalization from ``librosa.feature.logfsgram()`` +- Efficiency improvements by ensuring memory contiguity +- ``librosa.logamplitude()`` now supports functional reference power, + in addition + to scalar values +- Improved ``librosa.feature.delta()`` +- Additional padding options to ``librosa.feature.stack_memory()`` +- ``librosa.cqt`` and ``librosa.feature.logfsgram`` now use the same + parameter + formats ``(fmin, n_bins, bins_per_octave)``. +- Updated demo notebook(s) to IPython 2.0 +- Moved ``perceptual_weighting()`` from ``librosa.feature`` into + ``librosa.core`` +- Moved ``stack_memory()`` from ``librosa.segment`` into + ``librosa.feature`` +- Standardized ``librosa.output.annotation`` input format to match + ``mir_eval`` +- Standardized variable names (e.g., ``onset_envelope``). + +v0.2.1 +------ + +Bug fixes + +- fixed an off-by-one error in ``librosa.onset.onset_strength()`` +- fixed a sign-flip error in ``librosa.output.write_wav()`` +- removed all mutable object default parameters + +Features + +- added option ``centering`` to ``librosa.onset.onset_strength()`` to + resolve frame-centering issues with sliding window STFT +- added frame-center correction to ``librosa.core.frames_to_time()`` + and ``librosa.core.time_to_frames()`` +- added ``librosa.util.pad_center()`` +- added ``librosa.output.annotation()`` +- added ``librosa.output.times_csv()`` +- accelerated ``librosa.core.stft()`` and ``ifgram()`` +- added ``librosa.util.frame`` for in-place signal framing +- ``librosa.beat.beat_track`` now supports user-supplied tempo +- added ``librosa.util.normalize()`` +- added ``librosa.util.find_files()`` +- added ``librosa.util.axis_sort()`` +- new module: ``librosa.util()`` +- ``librosa.filters.constant_q`` now support padding +- added boolean input support for ``librosa.display.cmap()`` +- speedup in ``librosa.core.cqt()`` + +Other changes + +- optimized default parameters for ``librosa.onset.onset_detect`` +- set ``librosa.filters.mel`` parameter ``n_mels=128`` by default +- ``librosa.feature.chromagram()`` and ``logfsgram()`` now use power + instead of energy +- ``librosa.display.specshow()`` with ``y_axis='chroma'`` now labels as + ``pitch class`` +- set ``librosa.core.cqt`` parameter ``resolution=2`` by default +- set ``librosa.feature.chromagram`` parameter ``octwidth=2`` by + default + +v0.2.0 +------ + +Bug fixes + +- fixed default ``librosa.core.stft, istft, ifgram`` to match + specification +- fixed a float->int bug in peak\_pick +- better memory efficiency +- ``librosa.segment.recurrence_matrix`` corrects for width suppression +- fixed a divide-by-0 error in the beat tracker +- fixed a bug in tempo estimation with short windows +- ``librosa.feature.sync`` now supports 1d arrays +- fixed a bug in beat trimming +- fixed a bug in ``librosa.core.stft`` when calculating window size +- fixed ``librosa.core.resample`` to support stereo signals + +Features + +- added filters option to cqt +- added window function support to istft +- added an IPython notebook demo +- added ``librosa.features.delta`` for computing temporal difference + features +- new ``examples`` scripts: tuning, hpss +- added optional trimming to ``librosa.segment.stack_memory`` +- ``librosa.onset.onset_strength`` now takes generic spectrogram + function ``feature`` +- compute reference power directly in ``librosa.core.logamplitude`` +- color-blind-friendly default color maps in ``librosa.display.cmap`` +- ``librosa.core.onset_strength`` now accepts an aggregator +- added ``librosa.feature.perceptual_weighting`` +- added tuning estimation to ``librosa.feature.chromagram`` +- added ``librosa.core.A_weighting`` +- vectorized frequency converters +- added ``librosa.core.cqt_frequencies`` to get CQT frequencies +- ``librosa.core.cqt`` basic constant-Q transform implementation +- ``librosa.filters.cq_to_chroma`` to convert log-frequency to chroma +- added ``librosa.core.fft_frequencies`` +- ``librosa.decompose.hpss`` can now return masking matrices +- added reversal for ``librosa.segment.structure_feature`` +- added ``librosa.core.time_to_frames`` +- added cent notation to ``librosa.core.midi_to_note`` +- added time-series or spectrogram input options to ``chromagram``, + ``logfsgram``, ``melspectrogram``, and ``mfcc`` +- new module: ``librosa.display`` +- ``librosa.output.segment_csv`` => ``librosa.output.frames_csv`` +- migrated frequency converters to ``librosa.core`` +- new module: ``librosa.filters`` +- ``librosa.decompose.hpss`` now supports complex-valued STFT matrices +- ``librosa.decompose.decompose()`` supports ``sklearn`` decomposition + objects +- added ``librosa.core.phase_vocoder`` +- new module: ``librosa.onset``; migrated onset strength from + ``librosa.beat`` +- added ``librosa.core.pick_peaks`` +- ``librosa.core.load()`` supports offset and duration parameters +- ``librosa.core.magphase()`` to separate magnitude and phase from a + complex matrix +- new module: ``librosa.segment`` + +Other changes + +- ``onset_estimate_bpm => estimate_tempo`` +- removed ``n_fft`` from ``librosa.core.istft()`` +- ``librosa.core.mel_frequencies`` returns ``n_mels`` values by default +- changed default ``librosa.decompose.hpss`` window to 31 +- disabled onset de-trending by default in + ``librosa.onset.onset_strength`` +- added complex-value warning to ``librosa.display.specshow`` +- broke compatibilty with ``ifgram.m``; ``librosa.core.ifgram`` now + matches ``stft`` +- changed default beat tracker settings +- migrated ``hpss`` into ``librosa.decompose`` +- changed default ``librosa.decompose.hpss`` power parameter to ``2.0`` +- ``librosa.core.load()`` now returns single-precision by default +- standardized ``n_fft=2048``, ``hop_length=512`` for most functions +- refactored tempo estimator + +v0.1.0 +------ + +Initial public release. diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000000..4600ffbcf0 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,379 @@ +# -*- coding: utf-8 -*- +# +# librosa documentation build configuration file, created by +# sphinx-quickstart on Tue Jun 25 13:12:33 2013. +# +# This file is execfile()d with the current directory set to its containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +import os +import sys +import glob +import sphinx + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +sys.path.insert(0, os.path.abspath('../')) + +# -- General configuration ----------------------------------------------------- + +# If your documentation needs a minimal Sphinx version, state it here. +if sphinx.__version__ < "1.1": + raise RuntimeError("Sphinx 1.1 or newer is required") + +needs_sphinx = '1.1' + +# Add any Sphinx extension module names here, as strings. They can be extensions +# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. +extensions = ['sphinx.ext.autodoc', + 'sphinx.ext.viewcode', + 'sphinx.ext.intersphinx', + 'sphinx.ext.doctest', + 'numpydoc', + 'sphinx.ext.autosummary'] + + +autosummary_generate = True + +# Determine if the matplotlib has a recent enough version of the +# plot_directive. +try: + from matplotlib.sphinxext import plot_directive +except ImportError: + use_matplotlib_plot_directive = False +else: + try: + use_matplotlib_plot_directive = (plot_directive.__version__ >= 2) + except AttributeError: + use_matplotlib_plot_directive = False + +if use_matplotlib_plot_directive: + extensions.append('matplotlib.sphinxext.plot_directive') +else: + raise RuntimeError("You need a recent enough version of matplotlib") + +# Generate plots for example sections +numpydoc_use_plots = True + + +#-------- +# Doctest +#-------- + +doctest_global_setup = """ +import numpy as np +import scipy +import librosa +np.random.seed(123) +np.set_printoptions(precision=3, linewidth=64, edgeitems=2, threshold=200) +""" + +#------------------------------------------------------------------------------ +# Plot +#------------------------------------------------------------------------------ +plot_pre_code = """ +import seaborn +seaborn.set(style='ticks') +import numpy as np +import librosa +np.random.seed(123) +np.set_printoptions(precision=3, linewidth=64, edgeitems=2, threshold=200) +""" +plot_include_source = True +plot_formats = [('png', 96), 'pdf'] +plot_html_show_formats = False + +font_size = 13*72/96.0 # 13 px + +plot_rcparams = { + 'font.size': font_size, + 'axes.titlesize': font_size, + 'axes.labelsize': font_size, + 'xtick.labelsize': font_size, + 'ytick.labelsize': font_size, + 'legend.fontsize': font_size, + 'figure.subplot.bottom': 0.2, + 'figure.subplot.left': 0.2, + 'figure.subplot.right': 0.9, + 'figure.subplot.top': 0.85, + 'figure.subplot.wspace': 0.4, + 'text.usetex': False, + 'font.family': 'monospace', + 'font.monospace': ['Source Code Pro', 'Courier', + 'Fixed', 'Terminal', 'monospace'], +} + +if not use_matplotlib_plot_directive: + import matplotlib + matplotlib.rcParams.update(plot_rcparams) + + +numpydoc_show_class_members = False + +intersphinx_mapping = {'python': ('http://docs.python.org/2', None), + 'numpy': ('http://docs.scipy.org/doc/numpy/', None), + 'np': ('http://docs.scipy.org/doc/numpy/', None), + 'scipy': ('http://docs.scipy.org/doc/scipy/reference/', None), + 'matplotlib': ('http://matplotlib.sourceforge.net/', None), + 'sklearn': ('http://scikit-learn.org/stable/', None), + 'seaborn': ('http://stanford.edu/~mwaskom/software/seaborn/', None), + 'sns': ('http://stanford.edu/~mwaskom/software/seaborn/', None), + 'samplerate': + ('http://www.ar.media.kyoto-u.ac.jp/members/david/softwares/samplerate/sphinx/', None)} + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The suffix of source filenames. +source_suffix = '.rst' + +# The encoding of source files. +#source_encoding = 'utf-8-sig' + +# The master toctree document. +master_doc = 'index' + +# General information about the project. +project = u'librosa' +copyright = u'2016, librosa development team' + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. +# + +import imp +librosa_version = imp.load_source('librosa.version', '../librosa/version.py') +# The short X.Y version. +version = librosa_version.short_version +# The full version, including alpha/beta/rc tags. +release = librosa_version.version + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +#language = None + +# There are two options for replacing |today|: either, you set today to some +# non-false value, then it is used: +#today = '' +# Else, today_fmt is used as the format for a strftime call. +#today_fmt = '%B %d, %Y' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = ['_build'] + +# The reST default role (used for this markup: `text`) to use for all documents. +default_role = 'autolink' + +# If true, '()' will be appended to :func: etc. cross-reference text. +add_function_parentheses = False + +# If true, the current module name will be prepended to all description +# unit titles (such as .. function::). +add_module_names = True + +# If true, sectionauthor and moduleauthor directives will be shown in the +# output. They are ignored by default. +show_authors = False + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = 'sphinx' + +# A list of ignored prefixes for module index sorting. +# modindex_common_prefix = [] + +# -- RTD cruft --- + +import six + +if six.PY3: + from unittest.mock import MagicMock +else: + from mock import Mock as MagicMock + + +class Mock(MagicMock): + @classmethod + def __getattr__(cls, name): + return Mock() + + +# -- Options for HTML output ------------------------------------------------- + + +on_rtd = os.environ.get('READTHEDOCS', None) == 'True' +if on_rtd: + html_theme = 'default' + MOCK_MODULES = ['argparse', 'numpy', 'scipy', 'freetype', 'matplotlib'] + sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES) +else: + import sphinx_rtd_theme + html_theme = 'sphinx_rtd_theme' + html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# import sphinx_bootstrap_theme + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# html_theme_options = { +# 'bootswatch_theme': 'yeti', +# 'bootstrap_version': '3', +# 'navbar_title': 'LibROSA', +# 'source_link_position': None, +# } + +# Add any paths that contain custom themes here, relative to this directory. +# html_theme_path = sphinx_bootstrap_theme.get_html_theme_path() + +# The name for this set of Sphinx documents. If None, it defaults to +# " v documentation". +#html_title = None + +# A shorter title for the navigation bar. Default is the same as html_title. +#html_short_title = None + +# The name of an image file (relative to this directory) to place at the top +# of the sidebar. +#html_logo = None + +# The name of an image file (within the static path) to use as favicon of the +# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 +# pixels large. +#html_favicon = None + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] + +# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, +# using the given strftime format. +#html_last_updated_fmt = '%b %d, %Y' + +# If true, SmartyPants will be used to convert quotes and dashes to +# typographically correct entities. +# html_use_smartypants = True + +# Custom sidebar templates, maps document names to template names. +#html_sidebars = {} + +# Additional templates that should be rendered to pages, maps page names to +# template names. +#html_additional_pages = {} + +# If false, no module index is generated. +html_domain_indices = True + +# If false, no index is generated. +html_use_index = True + +html_use_modindex = True + +# If true, the index is split into individual pages for each letter. +# html_split_index = False + +# If true, links to the reST sources are added to the pages. +#html_show_sourcelink = True + +# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. +#html_show_sphinx = True + +# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. +#html_show_copyright = True + +# If true, an OpenSearch description file will be output, and all pages will +# contain a tag referring to it. The value of this option must be the +# base URL from which the finished HTML is served. +#html_use_opensearch = '' + +# This is the file name suffix for HTML files (e.g. ".xhtml"). +#html_file_suffix = None + +# Output file base name for HTML help builder. +htmlhelp_basename = 'librosadoc' + + +# -- Options for LaTeX output -------------------------------------------------- + +latex_elements = { +# The paper size ('letterpaper' or 'a4paper'). +#'papersize': 'letterpaper', + +# The font size ('10pt', '11pt' or '12pt'). +#'pointsize': '10pt', + +# Additional stuff for the LaTeX preamble. +#'preamble': '', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, author, documentclass [howto/manual]). +latex_documents = [ + ('index', 'librosa.tex', u'librosa Documentation', + u'The librosa development team', 'manual'), +] + +# The name of an image file (relative to this directory) to place at the top of +# the title page. +#latex_logo = None + +# For "manual" documents, if this is true, then toplevel headings are parts, +# not chapters. +#latex_use_parts = False + +# If true, show page references after internal links. +#latex_show_pagerefs = False + +# If true, show URL addresses after external links. +#latex_show_urls = False + +# Documents to append as an appendix to all manuals. +#latex_appendices = [] + +# If false, no module index is generated. +#latex_domain_indices = True + + +# -- Options for manual page output -------------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [ + ('index', 'librosa', u'librosa Documentation', + [u'The librosa development team'], 1) +] + +# If true, show URL addresses after external links. +#man_show_urls = False + + +# -- Options for Texinfo output ------------------------------------------------ + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + ('index', 'librosa', u'librosa Documentation', + u'The librosa development team', 'librosa', 'One line description of project.', + 'Miscellaneous'), +] + +# Documents to append as an appendix to all manuals. +#texinfo_appendices = [] + +# If false, no module index is generated. +#texinfo_domain_indices = True + +# How to display URL addresses: 'footnote', 'no', or 'inline'. +#texinfo_show_urls = 'footnote' + +autodoc_member_order = 'bysource' diff --git a/docs/core.rst b/docs/core.rst new file mode 100644 index 0000000000..a997706f3c --- /dev/null +++ b/docs/core.rst @@ -0,0 +1,3 @@ +.. _core: + +.. automodule:: librosa.core diff --git a/docs/decompose.rst b/docs/decompose.rst new file mode 100644 index 0000000000..681ff65cf3 --- /dev/null +++ b/docs/decompose.rst @@ -0,0 +1,3 @@ +.. _decompose: + +.. automodule:: librosa.decompose diff --git a/docs/display.rst b/docs/display.rst new file mode 100644 index 0000000000..bd5c6af65a --- /dev/null +++ b/docs/display.rst @@ -0,0 +1,3 @@ +.. _display: + +.. automodule:: librosa.display diff --git a/docs/effects.rst b/docs/effects.rst new file mode 100644 index 0000000000..2daa8a0b24 --- /dev/null +++ b/docs/effects.rst @@ -0,0 +1,3 @@ +.. _effects: + +.. automodule:: librosa.effects diff --git a/docs/feature.rst b/docs/feature.rst new file mode 100644 index 0000000000..1fb7cdb783 --- /dev/null +++ b/docs/feature.rst @@ -0,0 +1,3 @@ +.. _feature: + +.. automodule:: librosa.feature diff --git a/docs/filters.rst b/docs/filters.rst new file mode 100644 index 0000000000..ddb76240ee --- /dev/null +++ b/docs/filters.rst @@ -0,0 +1,3 @@ +.. _filters: + +.. automodule:: librosa.filters diff --git a/docs/glossary.rst b/docs/glossary.rst new file mode 100644 index 0000000000..cacebb8cb2 --- /dev/null +++ b/docs/glossary.rst @@ -0,0 +1,51 @@ +Glossary +======== + +.. glossary:: + + time series + Typically an audio signal, denoted by ``y``, and represented as a + one-dimensional *numpy.ndarray* of floating-point values. ``y[t]`` + corresponds to amplitude of the waveform at sample ``t``. + + sampling rate + The (positive integer) number of samples per second of a time series. + This is denoted by an integer variable ``sr``. + + frame + A short slice of a :term:`time series` used for analysis purposes. This + usually corresponds to a single column of a spectrogram matrix. + + window + A vector or function used to weight samples within a frame when computing + a spectrogram. + + frame length + The (positive integer) number of samples in an analysis window (or + :term:`frame`). + This is denoted by an integer variable ``n_fft``. + + hop length + The number of samples between successive frames, e.g., the columns + of a spectrogram. This is denoted as a positive integer ``hop_length``. + + window length + The length (width) of the window function (e.g., Hann window). Note that this + can be smaller than the :term:`frame length` used in a short-time Fourier + transform. Typically denoted as a positive integer variable ``win_length``. + + spectrogram + A matrix ``S`` where the rows index frequency bins, and the columns index + frames (time). Spectrograms can be either real-valued or complex-valued. By + convention, real-valued spectrograms are denoted as *numpy.ndarray*\ s ``S``, + while complex-valued STFT matrices are denoted as ``D``. + + onset (strength) envelope + An onset envelope ``onset_env[t]`` measures the strength of note onsets at + frame ``t``. Typically stored as a one-dimensional *numpy.ndarray* of + floating-point values ``onset_envelope``. + + chroma + Also known as pitch class profile (PCP). Chroma representations measure the + amount of relative energy in each pitch class (e.g., the 12 notes in the + chromatic scale) at a given frame/time. diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000000..283dd10c77 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,63 @@ +LibROSA +======= +LibROSA is a python package for music and audio analysis. It provides the building +blocks necessary to create music information retrieval systems. + +For a quick introduction to using librosa, please refer to the :doc:`tutorial`. +For a more advanced introduction which describes the package design principles, please refer to the +`librosa paper `_ at +`SciPy 2015 `_. + +Getting started +--------------- +.. toctree:: + :maxdepth: 1 + + install + tutorial + + +Troubleshooting +--------------- + +If you have questions about how to use librosa, please consult the `discussion forum +`_. +For bug reports and other, more technical issues, consult the `github issues +`_. + +API documentation +----------------- + +.. toctree:: + :maxdepth: 1 + + core + display + feature + onset + beat + decompose + effects + output + segment + util + + +Advanced topics +--------------- + +.. toctree:: + :maxdepth: 1 + + filters + cache + +Reference +--------- + +.. toctree:: + :maxdepth: 1 + + changelog + glossary +* :ref:`genindex` diff --git a/docs/install.rst b/docs/install.rst new file mode 100644 index 0000000000..c2fe64490b --- /dev/null +++ b/docs/install.rst @@ -0,0 +1,57 @@ +Installation instructions +========================= + +The simplest way to install *librosa* is through the Python Package Index (PyPI). This +will ensure that all required dependencies are fulfilled. This can be achieved by +executing the following command:: + + pip install librosa + +or:: + + sudo pip install librosa + +to install system-wide. + +If you've downloaded the archive manually from the `releases +`_ page, you can install using the +`setuptools` script:: + + tar xzf librosa-VERSION.tar.gz + cd librosa-VERSION/ + python setup.py install + +Additional notes +---------------- + +By default, *librosa* will use `scipy.signal` to resample audio signals, which can +be slow in practice. It is highly recommended to install `librsamplerate +`_ and the corresponding python module, +`scikits.samplerate `_. + +Once these are installed, *librosa* will use the faster `scikits.samplerate` for all +resampling operations. + + +Additional notes for OS X +------------------------- + +libsamplerate +------------- + +In order to use *scipy* with *libsamplerate*, you can use *homebrew* (http://brew.sh) +for installation: +``` +brew install libsamplerate +``` + +The Python bindings are installed via `pip install scikits.samplerate`. + +ffmpeg +------ + +To fuel `audioread` with more audio-decoding power, you can install *ffmpeg* which +ships with many audio decoders. + +You can use *homebrew* to install the programm by calling +`brew install ffmpeg` or get a binary version from their website https://www.ffmpeg.org. diff --git a/docs/onset.rst b/docs/onset.rst new file mode 100644 index 0000000000..35161adc8a --- /dev/null +++ b/docs/onset.rst @@ -0,0 +1,3 @@ +.. _onset: + +.. automodule:: librosa.onset diff --git a/docs/output.rst b/docs/output.rst new file mode 100644 index 0000000000..48c802dbaa --- /dev/null +++ b/docs/output.rst @@ -0,0 +1,3 @@ +.. _output: + +.. automodule:: librosa.output diff --git a/docs/segment.rst b/docs/segment.rst new file mode 100644 index 0000000000..bfc6e50810 --- /dev/null +++ b/docs/segment.rst @@ -0,0 +1,3 @@ +.. _segment: + +.. automodule:: librosa.segment diff --git a/docs/tutorial.rst b/docs/tutorial.rst new file mode 100644 index 0000000000..942fa63604 --- /dev/null +++ b/docs/tutorial.rst @@ -0,0 +1,281 @@ +Tutorial +======== + +This section covers the fundamentals of developing with *librosa*, including +a package overview, basic and advanced usage, and integration with the *scikit-learn* +package. We will assume basic familiarity with Python and NumPy/SciPy. + + +Overview +-------- + +The *librosa* package is structured as collection of submodules: + + - librosa + + - :ref:`librosa.beat ` + Functions for estimating tempo and detecting beat events. + + - :ref:`librosa.core ` + Core functionality includes functions to load audio from disk, compute various + spectrogram representations, and a variety of commonly used tools for + music analysis. For convenience, all functionality in this submodule is + directly accessible from the top-level ``librosa.*`` namespace. + + - :ref:`librosa.decompose ` + Functions for harmonic-percussive source separation (HPSS) and generic + spectrogram decomposition using matrix decomposition methods implemented in + *scikit-learn*. + + - :ref:`librosa.display ` + Visualization and display routines using `matplotlib`. + + - :ref:`librosa.effects ` + Time-domain audio processing, such as pitch shifting and time stretching. + This submodule also provides time-domain wrappers for the `decompose` + submodule. + + - :ref:`librosa.feature ` + Feature extraction and manipulation. This includes low-level feature + extraction, such as chromagrams, pseudo-constant-Q (log-frequency) transforms, + Mel spectrogram, MFCC, and tuning estimation. Also provided are feature + manipulation methods, such as delta features, memory embedding, and + event-synchronous feature alignment. + + - :ref:`librosa.filters ` + Filter-bank generation (chroma, pseudo-CQT, CQT, etc.). These are primarily + internal functions used by other parts of *librosa*. + + - :ref:`librosa.onset ` + Onset detection and onset strength computation. + + - :ref:`librosa.output ` + Text- and wav-file output. + + - :ref:`librosa.segment ` + Functions useful for structural segmentation, such as recurrence matrix + construction, time-lag representation, and sequentially constrained + clustering. + + - :ref:`librosa.util ` + Helper utilities (normalization, padding, centering, etc.) + + +.. _quickstart: + +Quickstart +---------- +Before diving into the details, we'll walk through a brief example program + +.. code-block:: python + :linenos: + + # Beat tracking example + from __future__ import print_function + import librosa + + # 1. Get the file path to the included audio example + filename = librosa.util.example_audio_file() + + # 2. Load the audio as a waveform `y` + # Store the sampling rate as `sr` + y, sr = librosa.load(filename) + + # 3. Run the default beat tracker + tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr) + + print('Estimated tempo: {:.2f} beats per minute'.format(tempo)) + + # 4. Convert the frame indices of beat events into timestamps + beat_times = librosa.frames_to_time(beat_frames, sr=sr) + + print('Saving output to beat_times.csv') + librosa.output.times_csv('beat_times.csv', beat_times) + + +The first step of the program:: + + filename = librosa.util.example_audio_file() + +gets the path to the audio example file included with *librosa*. After this step, +``filename`` will be a string variable containing the path to the example audio file. +The example is encoded in OGG Vorbis format, so you will need the appropriate codec +installed for `audioread `_. + +The second step:: + + y, sr = librosa.load(filename) + +loads and decodes the audio as a :term:`time series` ``y``, represented as a one-dimensional +NumPy floating point array. The variable ``sr`` contains the :term:`sampling rate` of +``y``, that is, the number of samples per second of audio. By default, all audio is +mixed to mono and resampled to 22050 Hz at load time. This behavior can be overridden +by supplying additional arguments to ``librosa.load()``. + +Next, we run the beat tracker:: + + tempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr) + +The output of the beat tracker is an estimate of the tempo (in beats per minute), +and an array of frame numbers corresponding to detected beat events. + +:term:`Frames ` here correspond to short windows of the signal (``y``), each +separated by ``hop_length = 512`` samples. Since v0.3, *librosa* uses centered frames, so +that the *k*\ th frame is centered around sample ``k * hop_length``. + +The next operation converts the frame numbers ``beat_frames`` into timings:: + + beat_times = librosa.frames_to_time(beat_frames, sr=sr) + +Now, ``beat_times`` will be an array of timestamps (in seconds) corresponding to +detected beat events. + +Finally, we can store the detected beat timestamps as a comma-separated values (CSV) +file:: + + librosa.output.times_csv('beat_times.csv', beat_times) + +The contents of ``beat_times.csv`` should look something like this:: + + 7.43 + 8.29 + 9.218 + 10.124 + ... + +This is primarily useful for visualization purposes (e.g., using +`Sonic Visualiser `_) or evaluation (e.g., using +`mir_eval `_). + + +Advanced usage +-------------- + +Here we'll cover a more advanced example, integrating harmonic-percussive separation, +multiple spectral features, and beat-synchronous feature aggregation. + +.. code-block:: python + :linenos: + + # Feature extraction example + import numpy as np + import librosa + + # Load the example clip + y, sr = librosa.load(librosa.util.example_audio_file()) + + # Separate harmonics and percussives into two waveforms + y_harmonic, y_percussive = librosa.effects.hpss(y) + + # Beat track on the percussive signal + tempo, beat_frames = librosa.beat.beat_track(y=y_percussive, + sr=sr) + + # Compute MFCC features from the raw signal + mfcc = librosa.feature.mfcc(y=y, sr=sr, hop_length=hop_length, n_mfcc=13) + + # And the first-order differences (delta features) + mfcc_delta = librosa.feature.delta(mfcc) + + # Stack and synchronize between beat events + # This time, we'll use the mean value (default) instead of median + beat_mfcc_delta = librosa.feature.sync(np.vstack([mfcc, mfcc_delta]), + beat_frames) + + # Compute chroma features from the harmonic signal + chromagram = librosa.feature.chroma_cqt(y=y_harmonic, + sr=sr) + + # Aggregate chroma features between beat events + # We'll use the median value of each feature between beat frames + beat_chroma = librosa.feature.sync(chromagram, + beat_frames, + aggregate=np.median) + + # Finally, stack all beat-synchronous features together + beat_features = np.vstack([beat_chroma, beat_mfcc_delta]) + + +This example builds on tools we've already covered in the :ref:`quickstart example +`, so here we'll focus just on the new parts. + +The first difference is the use of the :ref:`effects module ` for time-series +harmonic-percussive separation:: + + y_harmonic, y_percussive = librosa.effects.hpss(y) + +The result of this line is that the time series ``y`` has been separated into two time +series, containing the harmonic (tonal) and percussive (transient) portions of the +signal. Each of ``y_harmonic`` and ``y_percussive`` have the same shape and duration +as ``y``. + +The motivation for this kind of operation is two-fold: first, percussive elements +tend to be stronger indicators of rhythmic content, and can help provide more stable +beat tracking results; second, percussive elements can pollute tonal feature +representations (such as chroma) by contributing energy across all frequency bands, so +we'd be better off without them. + +Next, we introduce the :ref:`feature module ` and extract the Mel-frequency +cepstral coefficients from the raw signal ``y``:: + + mfcc = librosa.feature.mfcc(y=y, sr=sr, hop_length=hop_length, n_mfcc=13) + +The output of this function is the matrix ``mfcc``, which is an *numpy.ndarray* of +size ``(n_mfcc, T)`` (where ``T`` denotes the track duration in frames). Note that we +use the same ``hop_length`` here as in the beat tracker, so the detected ``beat_frames`` +values correspond to columns of ``mfcc``. + +The first type of feature manipulation we introduce is ``delta``, which computes +(smoothed) first-order differences among columns of its input:: + + mfcc_delta = librosa.feature.delta(mfcc) + +The resulting matrix ``mfcc_delta`` has the same shape as the input ``mfcc``. + +The second type of feature manipulation is ``sync``, which aggregates columns of its +input between sample indices (e.g., beat frames):: + + beat_mfcc_delta = librosa.feature.sync(np.vstack([mfcc, mfcc_delta]), + beat_frames) + +Here, we've vertically stacked the ``mfcc`` and ``mfcc_delta`` matrices together. The +result of this operation is a matrix ``beat_mfcc_delta`` with the same number of rows +as its input, but the number of columns depends on ``beat_frames``. Each column +``beat_mfcc_delta[:, k]`` will be the *average* of input columns between +``beat_frames[k]`` and ``beat_frames[k+1]``. (``beat_frames`` will be expanded to +span the full range ``[0, T]`` so that all data is accounted for.) + +Next, we compute a chromagram using just the harmonic component:: + + chromagram = librosa.feature.chroma_cqt(y=y_harmonic, + sr=sr) + +After this line, ``chromagram`` will be a *numpy.ndarray* of size ``(12, T)``, and +each row corresponds to a pitch class (e.g., *C*, *C#*, etc.). Each column of +``chromagram`` is normalized by its peak value, though this behavior can be overridden +by setting the ``norm`` parameter. + +Once we have the chromagram and list of beat frames, we again synchronize the chroma +between beat events:: + + beat_chroma = librosa.feature.sync(chromagram, + beat_frames, + aggregate=np.median) + +This time, we've replaced the default aggregate operation (*average*, as used above +for MFCCs) with the *median*. In general, any statistical summarization function can +be supplied here, including `np.max()`, `np.min()`, `np.std()`, etc. + +Finally, the all features are vertically stacked again:: + + beat_features = np.vstack([beat_chroma, beat_mfcc_delta]) + +resulting in a feature matrix ``beat_features`` of dimension +``(12 + 13 + 13, # beat intervals)``. + + +More examples +------------- + +More example scripts are provided in the `examples +`_ folder. diff --git a/docs/util.rst b/docs/util.rst new file mode 100644 index 0000000000..8ac02bcbd3 --- /dev/null +++ b/docs/util.rst @@ -0,0 +1,3 @@ +.. _util: + +.. automodule:: librosa.util diff --git a/examples/LibROSA audio effects and playback.ipynb b/examples/LibROSA audio effects and playback.ipynb new file mode 100644 index 0000000000..094a10cba1 --- /dev/null +++ b/examples/LibROSA audio effects and playback.ipynb @@ -0,0 +1,529 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Audio effects and playback with Librosa and IPython Notebook\n", + "\n", + "This notebook will demonstrate how to do audio effects processing with librosa and IPython notebook. You will need IPython 2.0 or later.\n", + "\n", + "By the end of this notebook, you'll know how to do the following:\n", + "\n", + " - Play audio in the browser\n", + " - Effect transformations such as harmonic/percussive source separation, time stretching, and pitch shifting\n", + " - Decompose and reconstruct audio signals with non-negative matrix factorization\n", + " - Visualize spectrogram data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from __future__ import print_function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import librosa\n", + "import IPython.display\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Load the example track\n", + "y, sr = librosa.load(librosa.util.example_audio_file())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Play it back!\n", + "IPython.display.Audio(data=y, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# How about separating harmonic and percussive components?\n", + "y_h, y_p = librosa.effects.hpss(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Play the harmonic component\n", + "IPython.display.Audio(data=y_h, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Play the percussive component\n", + "IPython.display.Audio(data=y_p, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Pitch shifting? Let's gear-shift by a major third (4 semitones)\n", + "y_shift = librosa.effects.pitch_shift(y, sr, 7)\n", + "\n", + "IPython.display.Audio(data=y_shift, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Or time-stretching? Let's slow it down\n", + "y_slow = librosa.effects.time_stretch(y, 0.5)\n", + "\n", + "IPython.display.Audio(data=y_slow, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# How about something more advanced? Let's decompose a spectrogram with NMF, and then resynthesize an individual component\n", + "D = librosa.stft(y)\n", + "\n", + "# Separate the magnitude and phase\n", + "S, phase = librosa.magphase(D)\n", + "\n", + "# Decompose by nmf\n", + "components, activations = librosa.decompose.decompose(S, n_components=8, sort=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1kAAAEaCAYAAADjUp3YAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nDViU4oInKNoAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the components and activations, just for fun\n", + "\n", + "plt.figure(figsize=(12,4))\n", + "\n", + "plt.subplot(1,2,1)\n", + "librosa.display.specshow(librosa.logamplitude(components**2.0, ref_power=np.max), y_axis='log')\n", + "plt.xlabel('Component')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Components')\n", + "\n", + "plt.subplot(1,2,2)\n", + "librosa.display.specshow(activations)\n", + "plt.xlabel('Time')\n", + "plt.ylabel('Component')\n", + "plt.title('Activations')\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1025, 8) (8, 2647)\n" + ] + } + ], + "source": [ + "print(components.shape, activations.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full reconstruction\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Play back the reconstruction\n", + "# Reconstruct a spectrogram by the outer product of component k and its activation\n", + "D_k = components.dot(activations)\n", + "\n", + "# invert the stft after putting the phase back in\n", + "y_k = librosa.istft(D_k * phase)\n", + "\n", + "# And playback\n", + "print('Full reconstruction')\n", + "\n", + "IPython.display.Audio(data=y_k, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Component #0\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Resynthesize. How about we isolate just first (lowest) component?\n", + "k = 0\n", + "\n", + "# Reconstruct a spectrogram by the outer product of component k and its activation\n", + "D_k = np.multiply.outer(components[:, k], activations[k])\n", + "\n", + "# invert the stft after putting the phase back in\n", + "y_k = librosa.istft(D_k * phase)\n", + "\n", + "# And playback\n", + "print('Component #{}'.format(k))\n", + "\n", + "IPython.display.Audio(data=y_k, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Component #4\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Resynthesize. How about we isolate a middle-frequency component?\n", + "k = len(activations) / 2\n", + "\n", + "# Reconstruct a spectrogram by the outer product of component k and its activation\n", + "D_k = np.multiply.outer(components[:, k], activations[k])\n", + "\n", + "# invert the stft after putting the phase back in\n", + "y_k = librosa.istft(D_k * phase)\n", + "\n", + "# And playback\n", + "print('Component #{}'.format(k))\n", + "\n", + "IPython.display.Audio(data=y_k, rate=sr)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Component #-1\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Resynthesize. How about we isolate just last (highest) component?\n", + "k = -1\n", + "\n", + "# Reconstruct a spectrogram by the outer product of component k and its activation\n", + "D_k = np.multiply.outer(components[:, k], activations[k])\n", + "\n", + "# invert the stft after putting the phase back in\n", + "y_k = librosa.istft(D_k * phase)\n", + "\n", + "# And playback\n", + "print('Component #{}'.format(k))\n", + "\n", + "IPython.display.Audio(data=y_k, rate=sr)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/LibROSA demo.ipynb b/examples/LibROSA demo.ipynb new file mode 100644 index 0000000000..6cc28c38b7 --- /dev/null +++ b/examples/LibROSA demo.ipynb @@ -0,0 +1,570 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Librosa demo\n", + "\n", + "This notebook demonstrates some of the basic functionality of librosa version 0.4.\n", + "\n", + "Following through this example, you'll learn how to:\n", + "\n", + "* Load audio input\n", + "* Compute mel spectrogram, MFCC, delta features, chroma\n", + "* Locate beat events\n", + "* Compute beat-synchronous features\n", + "* Display features\n", + "* Save beat tracker output to a CSV file" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from __future__ import print_function" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# We'll need numpy for some mathematical operations\n", + "import numpy as np\n", + "\n", + "# Librosa for audio\n", + "import librosa\n", + "\n", + "# matplotlib for displaying the output\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "# And seaborn to make it look nice\n", + "import seaborn\n", + "seaborn.set(style='ticks')\n", + "\n", + "# and IPython.display for audio output\n", + "import IPython.display" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "audio_path = librosa.util.example_audio_file()\n", + "\n", + "# or uncomment the line below and point it at your favorite song:\n", + "#\n", + "# audio_path = '/path/to/your/favorite/song.mp3'\n", + "\n", + "y, sr = librosa.load(audio_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, librosa will resample the signal to 22050Hz.\n", + "\n", + "You can change this behavior by saying:\n", + "```\n", + "librosa.load(audio_path, sr=44100)\n", + "```\n", + "to resample at 44.1KHz, or\n", + "```\n", + "librosa.load(audio_path, sr=None)\n", + "```\n", + "to disable resampling." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "###Warning\n", + "\n", + "You might want to stop here to verify that [scikits.samplerate](https://pypi.python.org/pypi/scikits.samplerate/0.3.3) is installed and functioning correctly. Without this, audio resampling will fall back on `scipy.signal.resample()`, which is rather inefficient.\n", + "\n", + "You can test this by printing out the `librosa.core.audio._HAS_SAMPLERATE` flag:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HAS_SAMPLERATE: True\n" + ] + } + ], + "source": [ + "print('HAS_SAMPLERATE: ', librosa.core.audio._HAS_SAMPLERATE)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mel spectrogram\n", + "This first step will show how to compute a [Mel](http://en.wikipedia.org/wiki/Mel_scale) spectrogram from an audio waveform." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxUAAAEVCAYAAACWgsgjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Let's make and display a mel-scaled power (energy-squared) spectrogram\n", + "S = librosa.feature.melspectrogram(y, sr=sr, n_mels=128)\n", + "\n", + "# Convert to log scale (dB). We'll use the peak power as reference.\n", + "log_S = librosa.logamplitude(S, ref_power=np.max)\n", + "\n", + "# Make a new figure\n", + "plt.figure(figsize=(12,4))\n", + "\n", + "# Display the spectrogram on a mel scale\n", + "# sample rate and hop length parameters are used to render the time axis\n", + "librosa.display.specshow(log_S, sr=sr, x_axis='time', y_axis='mel')\n", + "\n", + "# Put a descriptive title on the plot\n", + "plt.title('mel power spectrogram')\n", + "\n", + "# draw a color bar\n", + "plt.colorbar(format='%+02.0f dB')\n", + "\n", + "# Make the figure layout compact\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Harmonic-percussive source separation\n", + "\n", + "Before doing any signal analysis, let's pull apart the harmonic and percussive components of the audio. This is pretty easy to do with the `effects` module." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "y_harmonic, y_percussive = librosa.effects.hpss(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxMAAAGlCAYAAACBVqsRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n8rYIAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# What do the spectrograms look like?\n", + "# Let's make and display a mel-scaled power (energy-squared) spectrogram\n", + "S_harmonic = librosa.feature.melspectrogram(y_harmonic, sr=sr)\n", + "S_percussive = librosa.feature.melspectrogram(y_percussive, sr=sr)\n", + "\n", + "# Convert to log scale (dB). We'll use the peak power as reference.\n", + "log_Sh = librosa.logamplitude(S_harmonic, ref_power=np.max)\n", + "log_Sp = librosa.logamplitude(S_percussive, ref_power=np.max)\n", + "\n", + "# Make a new figure\n", + "plt.figure(figsize=(12,6))\n", + "\n", + "plt.subplot(2,1,1)\n", + "# Display the spectrogram on a mel scale\n", + "librosa.display.specshow(log_Sh, sr=sr, y_axis='mel')\n", + "\n", + "# Put a descriptive title on the plot\n", + "plt.title('mel power spectrogram (Harmonic)')\n", + "\n", + "# draw a color bar\n", + "plt.colorbar(format='%+02.0f dB')\n", + "\n", + "plt.subplot(2,1,2)\n", + "librosa.display.specshow(log_Sp, sr=sr, x_axis='time', y_axis='mel')\n", + "\n", + "# Put a descriptive title on the plot\n", + "plt.title('mel power spectrogram (Percussive)')\n", + "\n", + "# draw a color bar\n", + "plt.colorbar(format='%+02.0f dB')\n", + "\n", + "# Make the figure layout compact\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Chromagram\n", + "\n", + "Next, we'll extract [Chroma](http://en.wikipedia.org/wiki/Pitch_class) features to represent pitch class information." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwIAAAEVCAYAAABT8FKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nASGEEEIIIUYhCQSEEEIIIYQYhf4fEKo8lwae/5cAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We'll use a CQT-based chromagram here. An STFT-based implementation also exists in chroma_cqt()\n", + "# We'll use the harmonic component to avoid pollution from transients\n", + "C = librosa.feature.chroma_cqt(y=y_harmonic, sr=sr)\n", + "\n", + "# Make a new figure\n", + "plt.figure(figsize=(12,4))\n", + "\n", + "# Display the chromagram: the energy in each chromatic pitch class as a function of time\n", + "# To make sure that the colors span the full range of chroma values, set vmin and vmax\n", + "librosa.display.specshow(C, sr=sr, x_axis='time', y_axis='chroma', vmin=0, vmax=1)\n", + "\n", + "plt.title('Chromagram')\n", + "plt.colorbar()\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MFCC\n", + "\n", + "[Mel-frequency cepstral coefficients](http://en.wikipedia.org/wiki/Mel-frequency_cepstrum) are commonly used to represent texture or timbre of sound." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwQAAAGlCAYAAABEJDGAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Next, we'll extract the top 13 Mel-frequency cepstral coefficients (MFCCs)\n", + "mfcc = librosa.feature.mfcc(S=log_S, n_mfcc=13)\n", + "\n", + "# Let's pad on the first and second deltas while we're at it\n", + "delta_mfcc = librosa.feature.delta(mfcc)\n", + "delta2_mfcc = librosa.feature.delta(mfcc, order=2)\n", + "\n", + "# How do they look? We'll show each in its own subplot\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "plt.subplot(3,1,1)\n", + "librosa.display.specshow(mfcc)\n", + "plt.ylabel('MFCC')\n", + "plt.colorbar()\n", + "\n", + "plt.subplot(3,1,2)\n", + "librosa.display.specshow(delta_mfcc)\n", + "plt.ylabel('MFCC-$\\Delta$')\n", + "plt.colorbar()\n", + "\n", + "plt.subplot(3,1,3)\n", + "librosa.display.specshow(delta2_mfcc, sr=sr, x_axis='time')\n", + "plt.ylabel('MFCC-$\\Delta^2$')\n", + "plt.colorbar()\n", + "\n", + "plt.tight_layout()\n", + "\n", + "# For future use, we'll stack these together into one matrix\n", + "M = np.vstack([mfcc, delta_mfcc, delta2_mfcc])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Beat tracking\n", + "\n", + "The beat tracker returns an estimate of the tempo (in beats per minute) and frame indices of beat events.\n", + "\n", + "The input can be either an audio time series (as we do below), or an onset strength envelope as calculated by `librosa.onset.onset_strength()`." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAEVCAYAAAB9tXMgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now, let's run the beat tracker.\n", + "# We'll use the percussive component for this part\n", + "plt.figure(figsize=(12, 6))\n", + "tempo, beats = librosa.beat.beat_track(y=y_percussive, sr=sr)\n", + "\n", + "# Let's re-draw the spectrogram, but this time, overlay the detected beats\n", + "plt.figure(figsize=(12,4))\n", + "librosa.display.specshow(log_S, sr=sr, x_axis='time', y_axis='mel')\n", + "\n", + "# Let's draw transparent lines over the beat frames\n", + "plt.vlines(beats, 0, log_S.shape[0], colors='r', linestyles='-', linewidth=2, alpha=0.5)\n", + "\n", + "plt.axis('tight')\n", + "\n", + "plt.colorbar(format='%+02.0f dB')\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, the beat tracker will trim away any leading or trailing beats that don't appear strong enough. \n", + "\n", + "To disable this behavior, call `beat_track()` with `trim=False`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimated tempo: 103.36 BPM\n", + "First 5 beat frames: [ 4 28 53 77 102]\n", + "First 5 beat times: [ 0.09287982 0.65015873 1.2306576 1.78793651 2.36843537]\n" + ] + } + ], + "source": [ + "print('Estimated tempo: %.2f BPM' % tempo)\n", + "\n", + "print('First 5 beat frames: ', beats[:5])\n", + "\n", + "# Frame numbers are great and all, but when do those beats occur?\n", + "print('First 5 beat times: ', librosa.frames_to_time(beats[:5], sr=sr))\n", + "\n", + "# We could also get frame numbers from times by librosa.time_to_frames()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Beat-synchronous feature aggregation\n", + "\n", + "Once we've located the beat events, we can use them to summarize the feature content of each beat.\n", + "\n", + "This can be useful for reducing data dimensionality, and removing transient noise from the features." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwgAAAGmCAYAAADYjKOgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ntx29fAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# feature.sync will summarize each beat event by the mean feature vector within that beat\n", + "\n", + "M_sync = librosa.feature.sync(M, beats)\n", + "\n", + "plt.figure(figsize=(12,6))\n", + "\n", + "# Let's plot the original and beat-synchronous features against each other\n", + "plt.subplot(2,1,1)\n", + "librosa.display.specshow(M)\n", + "plt.title('MFCC-$\\Delta$-$\\Delta^2$')\n", + "\n", + "# We can also use pyplot *ticks directly\n", + "# Let's mark off the raw MFCC and the delta features\n", + "plt.yticks(np.arange(0, M.shape[0], 13), ['MFCC', '$\\Delta$', '$\\Delta^2$'])\n", + "\n", + "plt.colorbar()\n", + "\n", + "plt.subplot(2,1,2)\n", + "librosa.display.specshow(M_sync)\n", + "\n", + "# librosa can generate axis ticks from arbitrary timestamps and beat events also\n", + "librosa.display.time_ticks(librosa.frames_to_time(beats, sr=sr))\n", + "\n", + "plt.yticks(np.arange(0, M_sync.shape[0], 13), ['MFCC', '$\\Delta$', '$\\Delta^2$']) \n", + "plt.title('Beat-synchronous MFCC-$\\Delta$-$\\Delta^2$')\n", + "plt.colorbar()\n", + "\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAv8AAAGkCAYAAACmWkqLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Beat synchronization is flexible.\n", + "# Instead of computing the mean delta-MFCC within each beat, let's do beat-synchronous chroma\n", + "# We can replace the mean with any statistical aggregation function, such as min, max, or median.\n", + "\n", + "C_sync = librosa.feature.sync(C, beats, aggregate=np.median)\n", + "\n", + "plt.figure(figsize=(12,6))\n", + "\n", + "plt.subplot(2, 1, 1)\n", + "librosa.display.specshow(C, sr=sr, y_axis='chroma', vmin=0.0, vmax=1.0, x_axis='time')\n", + "plt.title('Chroma')\n", + "plt.colorbar()\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "librosa.display.specshow(C_sync, y_axis='chroma', vmin=0.0, vmax=1.0)\n", + "\n", + "beat_times = librosa.frames_to_time(beats, sr=sr)\n", + "librosa.display.time_ticks(beat_times)\n", + "\n", + "plt.title('Beat-synchronous Chroma (median aggregation)')\n", + "\n", + "plt.colorbar()\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.11" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples/adjust_tuning.py b/examples/adjust_tuning.py new file mode 100755 index 0000000000..0785365c0b --- /dev/null +++ b/examples/adjust_tuning.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python +'''CREATED:2014-05-22 16:43:44 by Brian McFee + +Pitch-shift a recording to be in A440 tuning. + +Usage: ./adjust_tuning.py [-h] input_file output_file +''' +from __future__ import print_function + +import argparse +import sys +import librosa + + +def adjust_tuning(input_file, output_file): + '''Load audio, estimate tuning, apply pitch correction, and save.''' + print('Loading ', input_file) + y, sr = librosa.load(input_file) + + print('Separating harmonic component ... ') + y_harm = librosa.effects.harmonic(y) + + print('Estimating tuning ... ') + # Just track the pitches associated with high magnitude + tuning = librosa.estimate_tuning(y=y_harm, sr=sr) + + print('{:+0.2f} cents'.format(100 * tuning)) + print('Applying pitch-correction of {:+0.2f} cents'.format(-100 * tuning)) + y_tuned = librosa.effects.pitch_shift(y, sr, -tuning) + + print('Saving tuned audio to: ', output_file) + librosa.output.write_wav(output_file, y_tuned, sr) + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser(description='Tuning adjustment example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') + + parser.add_argument('output_file', + action='store', + help='path to store the output wav') + + return vars(parser.parse_args(args)) + + +if __name__ == '__main__': + # Get the parameters + params = process_arguments(sys.argv[1:]) + + # Run the beat tracker + adjust_tuning(params['input_file'], params['output_file']) diff --git a/examples/beat_tracker.py b/examples/beat_tracker.py index 0c9bbb3058..88b264c9cf 100755 --- a/examples/beat_tracker.py +++ b/examples/beat_tracker.py @@ -2,29 +2,68 @@ ''' CREATED:2013-02-11 18:37:30 by Brian McFee -Do beat tracking on an audio file +Track beat events in an audio file -Usage: - -./beat_tracker.py input_file.mp3 output_beats.csv +Usage: ./beat_tracker.py [-h] input_file.mp3 output_beats.csv ''' +from __future__ import print_function + +import argparse +import sys +import librosa + + +def beat_track(input_file, output_csv): + '''Beat tracking function + + :parameters: + - input_file : str + Path to input audio file (wav, mp3, m4a, flac, etc.) + + - output_file : str + Path to save beat event timestamps as a CSV file + ''' + + print('Loading ', input_file) + y, sr = librosa.load(input_file, sr=22050) + + # Use a default hop size of 512 samples @ 22KHz ~= 23ms + hop_length = 512 + + # This is the window length used by default in stft + print('Tracking beats') + tempo, beats = librosa.beat.beat_track(y=y, sr=sr, hop_length=hop_length) + + print('Estimated tempo: {:0.2f} beats per minute'.format(tempo)) + + # save output + # 'beats' will contain the frame numbers of beat events. + beat_times = librosa.frames_to_time(beats, sr=sr, hop_length=hop_length) + + print('Saving output to ', output_csv) + librosa.output.times_csv(output_csv, beat_times) + print('done!') + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser(description='Beat tracking example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') -import sys, librosa + parser.add_argument('output_file', + action='store', + help='path to the output file (csv of beat times)') -# 1. load the wav file and resample to 22.050 KHz -print 'Loading ', sys.argv[1], '... ', -(y, sr) = librosa.load(sys.argv[1], target_sr=22050) -print 'done.' + return vars(parser.parse_args(args)) -# 2. extract beats -# Use a default hop size of 64 frames ~= 11.6ms -hop_length = 256 -print 'Extracting beats... ', -(bpm, beats) = librosa.beat.beat_track(y, sr, hop_length=hop_length) -print 'done. Estimated bpm: %.2f' % bpm +if __name__ == '__main__': + # Get the parameters + parameters = process_arguments(sys.argv[1:]) -# 3. save output -print 'Saving output... ', -librosa.output.segment_csv(sys.argv[2], beats, sr, hop_length) -print 'done.' + # Run the beat tracker + beat_track(parameters['input_file'], parameters['output_file']) diff --git a/examples/estimate_tuning.py b/examples/estimate_tuning.py new file mode 100755 index 0000000000..fe6d6602c6 --- /dev/null +++ b/examples/estimate_tuning.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python +'''CREATED:2013-12-09 00:02:54 by Brian McFee + +Estimate the tuning (deviation from A440) of a recording. + +Usage: ./tuning.py [-h] input_file +''' +from __future__ import print_function + +import argparse +import sys +import librosa + + +def estimate_tuning(input_file): + '''Load an audio file and estimate tuning (in cents)''' + + print('Loading ', input_file) + y, sr = librosa.load(input_file) + + print('Separating harmonic component ... ') + y_harm = librosa.effects.harmonic(y) + + print('Estimating tuning ... ') + # Just track the pitches associated with high magnitude + tuning = librosa.estimate_tuning(y=y_harm, sr=sr) + + print('{:+0.2f} cents'.format(100 * tuning)) + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser(description='Tuning estimation example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') + + return vars(parser.parse_args(args)) + + +if __name__ == '__main__': + # Get the parameters + parameters = process_arguments(sys.argv[1:]) + + # Run the beat tracker + estimate_tuning(parameters['input_file']) diff --git a/examples/hpss.py b/examples/hpss.py new file mode 100755 index 0000000000..5ddacb2162 --- /dev/null +++ b/examples/hpss.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python +'''CREATED:2013-12-08 14:28:34 by Brian McFee + +Demonstration of harmonic-percussive source separation +''' +from __future__ import print_function + +import argparse +import sys +import librosa + + +def hpss_demo(input_file, output_harmonic, output_percussive): + '''HPSS demo function. + + :parameters: + - input_file : str + path to input audio + - output_harmonic : str + path to save output harmonic (wav) + - output_percussive : str + path to save output harmonic (wav) + ''' + + # 1. Load the wav file, resample + print('Loading ', input_file) + + y, sr = librosa.load(input_file) + + # Separate components with the effects module + print('Separating harmonics and percussives... ') + y_harmonic, y_percussive = librosa.effects.hpss(y) + + # 5. Save the results + print('Saving harmonic audio to: ', output_harmonic) + librosa.output.write_wav(output_harmonic, y_harmonic, sr) + + print('Saving percussive audio to: ', output_percussive) + librosa.output.write_wav(output_percussive, y_percussive, sr) + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser(description='harmonic-percussive example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') + + parser.add_argument('output_harmonic', + action='store', + help='path to the harmonic output (wav)') + + parser.add_argument('output_percussive', + action='store', + help='path to the percussive output (wav)') + + return vars(parser.parse_args(args)) + + +if __name__ == '__main__': + # get the parameters + parameters = process_arguments(sys.argv[1:]) + + # Run the HPSS code + hpss_demo(parameters['input_file'], + parameters['output_harmonic'], + parameters['output_percussive']) diff --git a/examples/hpss_beats.py b/examples/hpss_beats.py index 0a895ae7ec..28918272ba 100755 --- a/examples/hpss_beats.py +++ b/examples/hpss_beats.py @@ -4,44 +4,83 @@ Beat tracking with HPSS filtering -Usage: - -./hpss_beats.py input_audio.mp3 output_beats.csv - +Usage: ./hpss_beats.py [-h] input_audio.mp3 output_beats.csv ''' +from __future__ import print_function +import argparse +import numpy as np import sys import librosa -import numpy, scipy.ndimage -SR = 22050 -HOP = 256 -FFT = 2048 +# Some magic number defaults, FFT window and hop length +N_FFT = 2048 + +# We use a hop of 512 here so that the HPSS spectrogram input +# matches the default beat tracker parameters +HOP_LENGTH = 512 + + +def hpss_beats(input_file, output_csv): + '''HPSS beat tracking + + :parameters: + - input_file : str + Path to input audio file (wav, mp3, m4a, flac, etc.) + + - output_file : str + Path to save beat event timestamps as a CSV file + ''' + + # Load the file + print('Loading ', input_file) + y, sr = librosa.load(input_file) + + # Do HPSS + print('Harmonic-percussive separation ... ') + y = librosa.effects.percussive(y) + + # Construct onset envelope from percussive component + print('Tracking beats on percussive component') + onset_env = librosa.onset.onset_strength(y=y, + sr=sr, + hop_length=HOP_LENGTH, + n_fft=N_FFT, + aggregate=np.median) + + # Track the beats + tempo, beats = librosa.beat.beat_track(onset_envelope=onset_env, + sr=sr, + hop_length=HOP_LENGTH) + + beat_times = librosa.frames_to_time(beats, + sr=sr, + hop_length=HOP_LENGTH) + + # Save the output + print('Saving beats to ', output_csv) + librosa.output.times_csv(output_csv, beat_times) + -# Load the file -print 'Loading file ... ', -(y, sr) = librosa.load(sys.argv[1], target_sr=SR) -print 'done.' +def process_arguments(args): + '''Argparse function to get the program parameters''' -# Construct log-amplitude spectrogram -print 'Harmonic-percussive separation ... ', -S = librosa.melspectrogram(y, sr, FFT, hop_length=HOP, mel_channels=128)**0.5 + parser = argparse.ArgumentParser(description='HPSS beat-tracking example') -# Do HPSS -(H, P) = librosa.hpss.hpss_median(S, p=4.0) -print 'done.' + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') -# Construct onset envelope from percussive component -print 'Beat tracking ... ', + parser.add_argument('output_file', + action='store', + help='path to the output file (csv of beat times)') -#O = librosa.beat.onset_strength(y, sr, window_length=FFT, hop_length=HOP, S=P) + return vars(parser.parse_args(args)) -# Use LoG(P) for the onset profile -O = numpy.mean(scipy.ndimage.gaussian_laplace(P, [1.0, 0.0]), axis=0) -# Track the beats -(bpm, beats) = librosa.beat.beat_track(y, sr, hop_length=HOP, onsets=O) -print 'done.' +if __name__ == '__main__': + # Get the parameters + parameters = process_arguments(sys.argv[1:]) -# Save the output -librosa.output.segment_csv(sys.argv[2], beats, sr, HOP) + # Run the beat tracker + hpss_beats(parameters['input_file'], parameters['output_file']) diff --git a/examples/onset_detector.py b/examples/onset_detector.py new file mode 100755 index 0000000000..a1ba61442f --- /dev/null +++ b/examples/onset_detector.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python +''' +CREATED:2014-06-04 11:43:30 by Colin Raffel + +Detect onsets in an audio file + +Usage: ./onset_detector.py [-h] input_file.mp3 output_onsets.csv +''' +from __future__ import print_function + +import sys +import librosa +import argparse + + +def onset_detect(input_file, output_csv): + '''Onset detection function + + :parameters: + - input_file : str + Path to input audio file (wav, mp3, m4a, flac, etc.) + + - output_file : str + Path to save onset timestamps as a CSV file + ''' + + # 1. load the wav file and resample to 22.050 KHz + print('Loading ', input_file) + y, sr = librosa.load(input_file, sr=22050) + + # Use a default hop size of 512 frames @ 22KHz ~= 23ms + hop_length = 512 + + # This is the window length used by default in stft + n_fft = 2048 + + # 2. run onset detection + print('Detecting onsets...') + onsets = librosa.onset.onset_detect(y=y, + sr=sr, + hop_length=hop_length) + + print("Found {:d} onsets.".format(onsets.shape[0])) + + # 3. save output + # 'beats' will contain the frame numbers of beat events. + + onset_times = librosa.frames_to_time(onsets, + sr=sr, + hop_length=hop_length, + n_fft=n_fft) + + print('Saving output to ', output_csv) + librosa.output.times_csv(output_csv, onset_times) + print('done!') + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser( + description='librosa onset detection example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') + + parser.add_argument('output_file', + action='store', + help='path to the output file (csv of onset times)') + + return vars(parser.parse_args(args)) + + +if __name__ == '__main__': + # Get the parameters + parameters = process_arguments(sys.argv[1:]) + + # Run the beat tracker + onset_detect(parameters['input_file'], parameters['output_file']) diff --git a/examples/time_stretch.py b/examples/time_stretch.py new file mode 100755 index 0000000000..8f9bbd9f72 --- /dev/null +++ b/examples/time_stretch.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python +'''CREATED:2013-12-08 14:28:34 by Brian McFee + +Demonstration of phase vocoder time stretching. +''' +from __future__ import print_function + +import argparse +import sys +import librosa + + +def stretch_demo(input_file, output_file, speed): + '''Phase-vocoder time stretch demo function. + + :parameters: + - input_file : str + path to input audio + - output_file : str + path to save output (wav) + - speed : float > 0 + speed up by this factor + ''' + + # 1. Load the wav file, resample + print('Loading ', input_file) + + y, sr = librosa.load(input_file) + + # 2. Time-stretch through effects module + print('Playing back at {:3.0f}% speed'.format(speed * 100)) + + y_stretch = librosa.effects.time_stretch(y, speed) + + print('Saving stretched audio to: ', output_file) + librosa.output.write_wav(output_file, y_stretch, sr) + + +def process_arguments(args): + '''Argparse function to get the program parameters''' + + parser = argparse.ArgumentParser(description='Time stretching example') + + parser.add_argument('input_file', + action='store', + help='path to the input file (wav, mp3, etc)') + + parser.add_argument('output_file', + action='store', + help='path to the stretched output (wav)') + + parser.add_argument('-s', '--speed', + action='store', + type=float, + default=2.0, + required=False, + help='speed') + + return vars(parser.parse_args(args)) + + +if __name__ == '__main__': + # get the parameters + parameters = process_arguments(sys.argv[1:]) + + # Run the HPSS code + stretch_demo(parameters['input_file'], + parameters['output_file'], + parameters['speed']) diff --git a/librosa/FeatureExtraction/HPA_HPSS.py b/librosa/FeatureExtraction/HPA_HPSS.py deleted file mode 100644 index 1339b7f75b..0000000000 --- a/librosa/FeatureExtraction/HPA_HPSS.py +++ /dev/null @@ -1,215 +0,0 @@ -def HPSS(x,nfft,noverlap,window,gamma,alpha,kmax): - - # [xharmony,xpercussion]=HPSS(x,nfft,noverlap,window,gamma,alpha,kmax) - # - # Splits the harmony and percussion of a wavfile. - # Prerquist: Fourier transformation function: stft.m/istft.m - # - # INPUTS - # x - wavfile, mono - # nfft - length of fft to use - # noverlap - length of overlap of fft - # window - length of window to use - # gamma - power spectrum reduction factor - # alpha - the degree of inital seperation - # kmax - number of iterations. - # - # OUTPUTS - # xharmony - the harmonic componant - # xpercussion - the percussive componant - # - # --------------------------------------------- - # Function created by M. McVicar - # Function revised by Y. Ni - # Intelligent Systems Lab - # University of Bristol - # U.K. - # 2011 - - F = stft(x,nfft,window,noverlap); - - # Power spectrum, reduced by gamma - import numpy as np - W = np.absolute(F)**(2.0*gamma); - - # 2. Initialise Harmony, Percussion and index. - H=0.5*W; - P=0.5*W; - - # 3. Evaluate the constants - a1=alpha*0.25; - a2=(1-alpha)*0.25; - [rowLen,colLen] = W.shape; - - # 4. Iteratively update the Harmony and Percussion matrix - Hnew=H.copy(); - Pnew=P.copy(); - - for k in range(kmax): - - print k - # 4.1 Do the boundary update. Its a square. - # Top - row=1-1; - for col in range(colLen): - Hnew[row,col] = min(max(2*H[row,col],0),W[row,col]); - Pnew[row,col] = W[row,col]-Hnew[row,col]; - - # Bottom - row=rowLen-1; - for col in range(colLen): - Hnew[row,col] = min(max(2*H[row,col],0),W[row,col]); - Pnew[row,col] = W[row,col]-Hnew[row,col]; - - # Left - col=1-1; - for row in range(1,rowLen-1): - Hnew[row,col] = min(max(2*H[row,col],0),W[row,col]); - Pnew[row,col] = W[row,col]-Hnew[row,col]; - - # Right - col=colLen-1; - for row in range(1,rowLen-1): - Hnew[row,col] = min(max(2*H[row,col],0),W[row,col]); - Pnew[row,col] = W[row,col]-Hnew[row,col]; - - # 4.2 calculate delta, update H and P - for col in range(1,colLen-1): - for row in range(1,rowLen-1): - delk = a1*(H[row,col-1]-2*H[row,col]+H[row,col+1])-a2*(P[row-1,col]-2*P[row,col]+P[row+1,col]); - Hnew[row,col] = min(max(H[row,col]+delk,0),W[row,col]); - Pnew[row,col] = W[row,col]-Hnew[row,col]; - - # 4.3 Each iteration - H=Hnew.copy(); - P=Pnew.copy(); - - # Binarise the result - Hfinal=H.copy(); - Pfinal=P.copy(); - - # 5. Get final P and H by binarising, i.e. taking the largest magnitude of H or P - for col in range(colLen): - for row in range(rowLen): - if H[row,col] < P[row,col]: - Hfinal[row,col] = 0; - Pfinal[row,col] = W[row,col]; - else: - Hfinal[row,col] = W[row,col]; - Pfinal[row,col] = 0; - - - # 6. now convert back to waveform - omegaH=np.zeros(F.shape,dtype=complex) - omegaP=np.zeros(F.shape,dtype=complex) - - update_factor=1.0/(2.0*gamma); - import cmath - for row in range(F.shape[0]): - for col in range(F.shape[1]): - phasepart = cmath.exp(1j*cmath.phase(F[row,col])); - omegaH[row,col] = (Hfinal[row,col]**update_factor)*phasepart; - omegaP[row,col] = (Pfinal[row,col]**update_factor)*phasepart; - - # 7. Take inverse short time Fourier transformation - xharmony = istft(omegaH,nfft,window,noverlap); - xpercussion = istft(omegaP,nfft,window,noverlap); - - return xharmony, xpercussion - -def stft(x, f, w, h): - # D = stft(X, F, W, H) - # Short-time Fourier transform. - # Returns some frames of short-term Fourier transform of x. Each - # column of the result is one F-point fft; each successive frame is - # offset by H points until X is exhausted. Data is hamm-windowed - # at W pts, or rectangular if W=0, or with W if it is a vector. - # See also 'istft.m'. - # dpwe 1994may05. Uses built-in 'fft' - # $Header: /homes/dpwe/public_html/resources/matlab/pvoc/RCS/stft.m,v 1.2 2009/01/07 04:32:42 dpwe Exp $ - - d = 0; - s = len(x); - - # sort out window types - import numpy as np - if type(w) is int: - if w == 0: - # special case: rectangular window - win = np.ones(f); - else: - if (w % 2) == 0: # force window to be odd-len - w = w + 1; - halflen = int((w-1)/2.0); - halff = int(f/2.0); # midpoint of win - halfwin = 0.5*(1+np.cos(np.pi*np.true_divide(range(halflen+1),halflen))) - win = np.zeros(f); - acthalflen = min(halff, halflen); - win[range(halff,halff+acthalflen)] = halfwin[range(acthalflen)]; - win[range(halff,halff-acthalflen,-1)] = halfwin[range(acthalflen)]; - else: - win = w; - w = len(w); - - c = 0; - # pre-allocate output array - d = np.zeros(((1+f/2.0),1+np.floor((s-f)/h)),dtype=complex); - - for b in range(0,s-f+1,h): - u = win*x[range(b,b+f)]; - t = np.fft.fft(u); - d[:,c] = t[range(1+int(f/2.0))]; - c = c+1; - - return d - -def istft(d, ftsize, w, h): - # Function: - # X = istft(D, F, W, H) - # Inverse short-time Fourier transform. - # Performs overlap-add resynthesis from the short-time Fourier transform - # data in D. Each column of D is taken as the result of an F-point - # fft; each successive frame was offset by H points. Data is - # hamm-windowed at W pts. - # W = 0 gives a rectangular window; W as a vector uses that as window. - # dpwe 1994may24. Uses built-in 'ifft' etc. - # $Header: /homes/dpwe/public_html/resources/matlab/pvoc/RCS/istft.m,v 1.4 2009/01/07 04:20:00 dpwe Exp $ - - s = d.shape; - cols = s[1]; - xlen = ftsize + (cols-1)*h; - import numpy as np - x = np.zeros(xlen); - - # sort out window types - if type(w) is int: - if w == 0: - # special case: rectangular window - win = np.ones(ftsize); - else: - if (w % 2) == 0: # force window to be odd-len - w = w + 1; - halflen = int((w-1)/2.0); - halff = int(ftsize/2.0); # midpoint of win - halfwin = 0.5*(1+np.cos(np.pi*np.true_divide(range(halflen+1),halflen))) - win = np.zeros(ftsize); - acthalflen = min(halff, halflen); - win[range(halff,halff+acthalflen)] = halfwin[range(acthalflen)]; - win[range(halff,halff-acthalflen,-1)] = halfwin[range(acthalflen)]; - # 2009-01-06: Make stft-istft loop be identity - win = np.true_divide(2.0*win,3.0); - else: - win = w; - w = len(w); - - # Grab the ifft of each column, weighted by win - for b in range(0,(h*(cols-1)),h): - ft = d[:,int(b/h)]; - r = range(int(ftsize/2)-1,0,-1); - part_two = np.conj(ft[r]); - ft = np.hstack([ft,part_two]); - px = np.real(np.fft.ifft(ft)); - x[range(b,b+ftsize)] = x[range(b,b+ftsize)]+px*win; - - return x - diff --git a/librosa/FeatureExtraction/HPA_beat_tracker.py b/librosa/FeatureExtraction/HPA_beat_tracker.py deleted file mode 100644 index fc4e809398..0000000000 --- a/librosa/FeatureExtraction/HPA_beat_tracker.py +++ /dev/null @@ -1,465 +0,0 @@ -def estimate_beats(d,sr,startbpm,tightness): - # Function: - # [bts, bpm]=estimate_beats(d,sr,startbpm,tightness) - # - # Get beat times (in seconds) and bpm of a wav file. - # - # INPUTS - # - d. The waveform, matlab mono vector. - # - sr. Waveform sampling rate. - # - startbpm. The start point of the search. - # - tightness. How tightly to stick to the startbpm. - # - # OUTPUTS - # - bts. vector of beat occurances in seconds. - # - bpm. Estimate of the beats per minute. - # - # Use "beat tracker" (last argument is 0 for noplot) - - bts = 0; - - # Get the beat times - [BeatStrength, downsample, hop_len] = calculate_beat_strength(d,sr); - - bts = beatestimate(BeatStrength,downsample,hop_len,startbpm,tightness); - - #bts = beat(d,sr,startbpm,tightness,0); - - # Estimate bpm as median beat difference. - import numpy as np - bpm = np.true_divide(60.0,np.median(np.diff(bts))); - - # Post-processing: if bpm<120, double everything. - if bpm < 120: - new_beats = [bts[0]]; - for b in range(1,bts.shape[0]): - new_beats = np.hstack([new_beats, (bts[b-1]+bts[b])/2.0, bts[b]]); - bts=new_beats; - - return bts - -def calculate_beat_strength(x,sr,downsample=8000,win_len=256,hop_len=32,mel_channels=40): - - # Function: - #[BeatStrength, estimateBPM, options]=calculate_beat_strength(x,sr,downsample,win_len,... - # hop_len, mel_channels) - # - # This function calculates the beat strength through a file, which can be fed into - # beatestimate.m to estimate beat positions. - # - # Prerquist: hz2mel and mel2hz. - # - # INPUTS - x. Mono waveform. - # - sr. Sample rate of x. - # - downsample. New sample frequency. - # - win_len. Length of STFT to use. - # - hop_len. Hop of STFT to use. - # - mel_channels. Number of Mel bands to use. - # - # OUTPUTS - BeatStrength. The beat strengths. - # - options. The options used in this function. - # - # --------------------------------------------- - # Function created by M. McVicar - # Function revised by Y. Ni - # Intelligent Systems Lab - # University of Bristol - # U.K. - # 2011 - - # hcf of new sr and sr - #import fractions - #gg = fractions.gcd(downsample,sr); - - # Resample and use downsample from now on - from scipy import signal - import numpy as np - # DEBUG: don't downsample - downsample = sr; - #l = len(x)*np.true_divide(downsample,sr); - #x = signal.resample(x,l); - #sr=downsample; - - # Take stft - import HPA_stftistft as stftistft - D = stftistft.stft(x,win_len,win_len,hop_len); - - # Mel parameters - width = 1.0; - minfrq = 0; - maxfrq = sr/2.0; # Use the Nyquist - htkmel = 0; - - # Initialise weights - wts = np.zeros([mel_channels, win_len]); - - # Get the normal fft frequencies - fftfrqs=np.true_divide(np.multiply(range(win_len/2+1),sr),win_len); - - # Get the centers of the Mel frequencies - mimel_channels = hz2mel(minfrq, htkmel); - maxmel = hz2mel(maxfrq, htkmel); - - # binfrqs are the nearest fft frequencies to the mel frequencies - binfrqs = np.zeros(mel_channels+2); - for f in range(mel_channels+2): - binfrqs[f] = mel2hz(np.true_divide(mimel_channels+(f),(mel_channels+1))*(maxmel-mimel_channels), htkmel); - - # work out weights - for i in range(mel_channels): - - fs = binfrqs[i+np.array([0, 1, 2])]; - - # scale by width - fs = fs[1]+np.multiply(width,(fs - fs[1])); - - # lower and upper slopes for all bins - loslope = np.true_divide((fftfrqs - fs[0]),(fs[1] - fs[0])); - hislope = np.true_divide((fs[2] - fftfrqs),(fs[2] - fs[1])); - - # intersect them with each other and zero - temp = np.zeros(loslope.shape); - for j in range(len(temp)): - temp[j] = max(0,min(loslope[j],hislope[j])) - - wts[i,(range(win_len/2 + 1))] = temp; - - # Slaney-style mel is scaled to be approx constant E per channel - const_one = binfrqs[range(2,mel_channels+2)]; - const_two = binfrqs[range(mel_channels)]; - wts = np.dot(np.diag(np.true_divide(2,(const_one-const_two))),wts); - - # Make sure 2nd half of FFT is zero - wts[:,range((win_len/2+1),win_len)] = 0.0; - - # Use these weights to convert the fft scale to mel scale - D_mel=np.dot(wts[:,range((win_len/2)+1)],abs(D)); - - # Post-process. Take the non numerically zero part - D_nonzero = np.maximum(1e-10,D_mel); - - # Convert to dB - D_dB=20.0*np.log10(D_nonzero); - - # only look at top 80 dB - D_trimmed = np.maximum(D_dB,D_dB.max()-80.0); - - # Take first difference - D_diff=np.diff(D_trimmed,1,1); - - # Use nonzero part - D_nz=np.maximum(0.0,D_diff); - - # Take average over mel bands - D_raw_envelope=np.mean(D_nz,0); - - # filter with a simple window - from scipy.signal import lfilter - D_windowed = lfilter([1.0,-1.0], [1.0,-.99],D_raw_envelope); - - # Divide by standard deviation - BeatStrength = D_windowed.copy(); #D_windowed/std(D_windowed); - - return BeatStrength, downsample, hop_len - -def hz2mel(f,htk=0): - # z = hz2mel(f,htk) - # Convert frequencies f (in Hz) to mel 'scale'. - # Optional htk = 1 uses the mel axis defined in the HTKBook - # otherwise use Slaney's formula - # 2005-04-19 dpwe@ee.columbia.edu - - #if nargin < 2 - #htk = 0; - #end - - import numpy as np - if htk == 1: - z = 2595 * np.log10(1+np.true_divide(f,700.0)); - else: - # Mel fn to match Slaney's Auditory Toolbox mfcc.m - - f_0 = 0.0; # 133.33333; - f_sp = 200.0/3.0; # 66.66667; - brkfrq = 1000.0; - brkpt = np.true_divide((brkfrq - f_0),f_sp); # starting mel value for log region - logstep = np.exp(np.true_divide(np.log(6.4),27.0)); - # magic 1.0711703 which is the ratio needed to get from 1000 Hz to 6400 Hz in - # 27 steps, and is *almost* the ratio between 1000 Hz and the preceding linear - # filter center at 933.33333 Hz (actually 1000/933.33333 = 1.07142857142857 and - # exp(log(6.4)/27) = 1.07117028749447) - if (f < brkfrq): - # fill in parts separately - z = np.true_divide((f - f_0),f_sp); - else: - z = brkpt+(np.true_divide(np.log(np.true_divide(f,brkfrq)),np.log(logstep))); - - mel = z; - return mel - -def mel2hz(z, htk=0): - # f = mel2hz(z, htk) - # Convert 'mel scale' frequencies into Hz - # Optional htk = 1 means use the HTK formula - # else use the formula from Slaney's mfcc.m - # 2005-04-19 dpwe@ee.columbia.edu - - if htk == 1: - f = 700.0*(10.0**(z/2595.0)-1.0); - else: - - import numpy as np - f_0 = 0.0; # 133.33333; - f_sp = 200.0/3.0; # 66.66667; - brkfrq = 1000.0; - brkpt = np.true_divide((brkfrq - f_0),f_sp); # starting mel value for log region - logstep = np.exp(np.log(6.4)/27.0); # see 'magic comment in hz2mel - - if (z < brkpt): - f = f_0 + f_sp*z; - else: - f = brkfrq*np.exp(np.log(logstep)*(z-brkpt)); - - return f - -def beatestimate(BeatStrength,sr,hop,startbpm,beat_tightness): - # Function: - # Beats=beatestimate(BeatStrength,sr,hop,startbpm,... - # beat_tightness) - # - # This function estimates the beat times from the beat strength. - # - # INPUTS - BeatStrength. The strength of the beat, time windowed by a stft - # - sr. Sample rate of BeatStrength (note this might have been - # resampled. - # - hop. number of samples hopped in BeatStrength - # - startbpm. The start point of the search. - # - tightness. How tightly to stick to the startbpm. - # - # OUTPUTS - Beats. The beat times in seconds - # - #--------------------------------------------- - #Function created by M. McVicar - #Function revised by Y. Ni - #Intelligent Systems Lab - #University of Bristol - #U.K. - #2011 - - Beats = 0; - - # 1. Estimate rough start bpm - - # Find rough global period (empirically, 0s-90s) - duration_time = 90.0; #in seconds - upper_time_zone = 90.0; #in seconds - bpm_std = 0.7; #the variance of the bpm window - alpha = 0.8; #a update weight for part 3. - - # sample rate for specgram frames (due to the hop_length) - import numpy as np - fftres = np.true_divide(sr,hop); - - # Get the lower bound and the upper bound in the beat strength vector - maxcol = int(min(np.round(upper_time_zone*fftres),len(BeatStrength)-1)); - mincol = int(max(1,maxcol-np.round(duration_time*fftres))); - - # Use auto-correlation out of 4 seconds (empirically set?) - acmax = int(np.round(4*fftres)); - - # Get autocorrelation of signal - import matplotlib.pyplot as plt - - # matlab auto zero-pads, python doesn't - if BeatStrength.shape[0] >= acmax: - rrr = plt.xcorr(BeatStrength[range(mincol-1,maxcol)],BeatStrength[range(mincol-1,maxcol)],normed=False,maxlags=acmax) - xcr = rrr[1] - else: - maxlaglen = len(BeatStrength[range(mincol-1,maxcol)])-1; - rrr = plt.xcorr(BeatStrength[range(mincol-1,maxcol)],BeatStrength[range(mincol-1,maxcol)],normed=False,maxlags=maxlaglen) - xcr = rrr[1] - des_len = acmax*2+1 - npad = (des_len-len(xcr))/2 - xcr = np.hstack([np.zeros(npad),xcr,np.zeros(npad)]) - - # Find local max in the global auto-correlation - rawxcr = xcr[range(acmax,2*acmax+1)]; # The right side of correlation part - - # Creating a hamming like window around default bpm - bpms = 60.0*np.true_divide(fftres,(np.add(range(acmax+1),0.1))); - - num = np.log(np.true_divide(bpms,startbpm))*bpm_std; - denom = np.log(2.0); - div = np.true_divide(num,denom); - xcrwin = np.exp(-0.5*div**2.0); - - # The weighted auto-correlation - xcr = rawxcr*xcrwin; - - # %Add in 2x, 3x, choose largest combined peak - # lxcr = length(xcr); - # xcr00 = [0, xcr, 0]; - # xcr2 = xcr(1:ceil(lxcr/2))+.5*(.5*xcr00(1:2:lxcr)+xcr00(2:2:lxcr+1)+.5*xcr00(3:2:lxcr+2)); - # xcr3 = xcr(1:ceil(lxcr/3))+.33*(xcr00(1:3:lxcr)+xcr00(2:3:lxcr+1)+xcr00(3:3:lxcr+2)); - # - # - # %Get the bpm position of the peak - # if max(xcr2) > max(xcr3) - # [vv, startpd] = max(xcr2); - # startpd = startpd -1; - # startpd2 = startpd*2; - # else - # [vv, startpd] = max(xcr3); - # startpd = startpd -1; - # startpd2 = startpd*3; - # end - - # %Get the local max (the picks) - xpks = localmax(xcr); - - #Not include any peaks in first down slope (before goes below - # zero for the first time) - xpks[range(np.min(np.nonzero(xcr<0)))] = 0; - - #Largest local max away from zero - maxpk = np.max(xcr[xpks]); - - #Find the position of the first largest pick - z = np.nonzero((xpks*xcr) == maxpk); - startpd = z[0]; - startpd = startpd[0]; - - # Choose best peak out of .33 .5 2 3 x this period - candpds = np.round(np.multiply([.33, .5, 2.0, 3.0],startpd)).astype(int); - candpds = candpds[candpds < acmax]; - - bestpd2 = np.argmax(xcr[candpds])+1; # to match matlab - startpd2 = candpds[bestpd2]; - - # %Weight startpd and startpd2 - # pratio = xcr(1+startpd)/(xcr(1+startpd)+xcr(1+startpd2)); - # if (pratio>0.5) - # startbpm=(60*fftres)/startpd; - # else - # startbpm=(60*fftres)/startpd2; - # end - - #Always use the faster one - startbpm = np.true_divide(60.0*fftres,np.minimum(startpd,startpd2)); - - ### 1. Smooth the beat strength ### - - # BeatStrength=BeatStrength/std(BeatStrength); - - startpd = int(round(60.0*fftres)/startbpm); - pd = startpd; - - # Smooth beat events with a gaussian window - templt = np.exp(-0.5*(((range(-pd,pd+1))/(np.true_divide(pd,32.0)))**2.0)); - - # convolve the window with the BeatStrength - import scipy.signal - localscore = scipy.signal.fftconvolve(templt,BeatStrength); - localscore = localscore[np.add(int(round(len(templt)/2.0)),range(BeatStrength.shape[0]))]; - - ### 2.Initialise ### - - backlink = np.zeros(localscore.shape[0]); - cumscore = np.zeros(localscore.shape[0]); - - # search range for previous beat. prange is the number of samples to look - # back and forward - # prange = round(-2*pd):-round(pd/2); - prange = np.round(range(-2*pd,-pd/2+1)); - - # Make a score window, which begins biased towards 120bpm and skewed. - # txwt = (-beat_tightness*abs((log(prange/-pd)).^2)); - txwt = np.exp(-0.5*(beat_tightness*(np.log(np.true_divide(prange,-pd))))**2.0); - - # 'Starting' is 1 for periods of (near) silence. - starting = 1; - - ### 3 Forward step ### - - # Main forward loop. Go through each window, padding zeros backwards if - # needed, and add the cumulative score to the prior (txwt). - for i in range(localscore.shape[0]): - #for i in range(1): - - # Move the time window along - timerange = np.add(i,prange); - - # Are we reaching back before time zero? - zpad = np.maximum(0, np.minimum(1-timerange[0],prange.shape[0])); - - # Search over all possible predecessors and apply transition - # weighting - scorecands = txwt*np.hstack([np.zeros(zpad),cumscore[timerange[zpad:]]]); - - # Find best predecessor beat - current_score = np.max(scorecands); - beat_location = np.argmax(scorecands); - - # Add on local score - cumscore[i] = alpha*current_score + (1-alpha)*localscore[i]; - - # special case to catch first onset. Stop if the local score is small (ie - # if there's near silence) - if ((starting == 1) and (localscore[i] < 0.01*np.max(localscore))): - backlink[i] = -1; # default - else: - # found a probable beat, store it and leave the starting/silence - # scenario. - backlink[i] = timerange[beat_location]; - starting = 0; - - ### 4. Get the last beat ### - - # cumscore now stores the score through the song, backlink the best - # previous frame. - - # get the median non zero score - maxes = localmax(cumscore); - max_indices = np.nonzero(maxes)[0]; - peak_scores = cumscore[max_indices]; - - medscore = np.median(peak_scores); - - # look for beats above 0.5 * median - bestendposs = np.nonzero(cumscore * localmax(cumscore) > 0.5*medscore)[0]; - - # The last of these is the last beat (since the score generally increases) - bestendx = np.max(bestendposs); - - ### 5. Backtrace ### - # begin on last beat - b = [int(bestendx)]; - - # go while backlink is positive (we set it to be -1 in silence) - while backlink[b[-1]] > 0: - # append the previous beat - b = np.hstack([b,int(backlink[b[-1]])]); - - ### 6. Output ### - # Beats are currently backwards, so flip. Also return in s (need +1) - b = b[ ::-1]; - Beats = np.true_divide(np.add(b,1),fftres); - - return Beats - -def localmax(x): - # return 1 where there are local maxima in x (columnwise). - # don't include first point, maybe last point - - import numpy as np - - ''' m = localmax(a) - return 1 where there are local maxima in x (columnwise). - don't include first point, maybe last point''' - - #return np.append([0], np.logical_and(x[1:] > x[:-1], x[:-1] < x[1:])) - #m = (x > [x(1),x(1:(lx-1))]) & (x >= [x(2:lx),1+x(lx)]); - lx = x.shape[0]; - m = np.logical_and(x > np.hstack([x[0],x[range(lx-1)]]),x >= np.hstack([x[range(1,lx)],x[lx-1]])); - - return m diff --git a/librosa/FeatureExtraction/HPA_extract_chroma.py b/librosa/FeatureExtraction/HPA_extract_chroma.py deleted file mode 100644 index d67b8afca6..0000000000 --- a/librosa/FeatureExtraction/HPA_extract_chroma.py +++ /dev/null @@ -1,29 +0,0 @@ -def extract_chroma(filename, disp=1, rs=11025, tune_fft=4096, tune_ctr=400.0, tune_sd=1.0, - HPSS_len=1024, HPSS_hop=512, HPSS_win=4096, HPSS_alph=0.3, HPSS_gamma=0.3, - HPSS_kmax=1, wavewrite=0, beat_startbpm=120, beat_tight=3, - fmin=220.0, fmax=1661.0, res_fact=5.0, LBC_ref='s',LBC_Aweight=1, - LBC_q=0.0, LBC_norm='n'): - - # Main process for extracting a chromagram. - # Use keyword arguments in the three main functions. - - # 1. HPSS, Tuning and beat estimate - import HPA_feature_extraction as HPA_feat - reload(HPA_feat) - [xharmony, semisoff, resample_rate, beat_times] = HPA_feat.extract_harmony_from_audio(filename, - display=disp, resample_rate=rs, tuning_fftlen=tune_fft, f_ctr=tune_ctr, - f_sd=tune_sd, HPSS_fftlen=HPSS_len, HPSS_hoplen=HPSS_hop, - HPSS_window=HPSS_win, gamma=HPSS_gamma, alpha=HPSS_gamma, kmax=HPSS_kmax, - write_wav=wavewrite, startbpm=beat_startbpm, beat_tightness=beat_tight) - - # 2. Calculate hamming windows - [hamming_k, half_winLenK, freqBins] = HPA_feat.cal_hamming_window(resample_rate, - minFreq=fmin, maxFreq=fmax, resolution_fact=res_fact,tuning=semisoff) - - # 3. Extract chroma - [chromagram, normal_chromagram, sample_times] = HPA_feat.cal_CQ_chroma_loudness(xharmony, - resample_rate, beat_times, hamming_k, half_winLenK, freqBins, - refLabel=LBC_ref, A_weightLabel=LBC_ref, q_value=LBC_ref, normFlag=LBC_norm) - - return chromagram, normal_chromagram, sample_times, semisoff - \ No newline at end of file diff --git a/librosa/FeatureExtraction/HPA_feature_extraction.py b/librosa/FeatureExtraction/HPA_feature_extraction.py deleted file mode 100644 index 2b08b02b8c..0000000000 --- a/librosa/FeatureExtraction/HPA_feature_extraction.py +++ /dev/null @@ -1,421 +0,0 @@ -def extract_harmony_from_audio(wavfilename,display=1,resample_rate=11025,tuning_fftlen=4096,f_ctr=400.0,f_sd=1.0,HPSS_fftlen=1024,HPSS_hoplen=512,HPSS_window=4096,gamma=0.3,alpha=0.3,kmax=1,write_wav=0,startbpm=120,beat_tightness=3): - - # Main function for extractnig harmony from audio. Main steps: - # 1. Read wave file - # 2. Collapse to mono - # 3. Resample - # 4. Estimate tuning - # 5. Split Harmony and Percussion - # 6. Estimate beats - # Returns harmony (the harmony wave), the estimated tuning, the new sample - # rate, and the the estimated beat times - - # Default options below - - ##### 1. Read wav file ##### - if display == 1: print "Reading wave..."; - import scipy.io.wavfile as wavfile - audio_data = wavfile.read(wavfilename) - - # Extract parts - import numpy as np - sr = audio_data[0]; - x = audio_data[1]; - n_channels = np.ndim(x); - - ##### 2. Collapse to mono and normalise ##### - if display == 1: print "Converting to mono and normalising..."; - if n_channels > 1: - x = np.mean(x,1) - x = np.true_divide(x,2**15) - - ##### 3. Resample ##### - if display == 1: print "Resampling..."; - from scipy import signal - if sr != resample_rate: - l = len(x)*np.true_divide(resample_rate,sr); - x = signal.resample(x,l); - - ##### 4. Estimate tuning ##### - if display == 1: print "Estimating tuning..."; - import HPA_tuning as tuning - semisoff = tuning.estimate_tuning(x,resample_rate,tuning_fftlen,f_ctr,f_sd); - - ##### 5. Do HPSS ##### - if display == 1: print "Splitting harmony and Percussion..."; - #[xharmony,xperc] = HPSS(x,HPSS_fftlen,HPSS_hoplen,HPSS_window,gamma,alpha,kmax); - xharmony = x; - - ###### 6. Write the wav? ###### - if write_wav == 1: - print "Writing harmony wav..."; - write_wave(xharmony,'test.wav',resample_rate,1); - - #### 6. Estimate beats ##### - if display == 1: print "Estimating beat times..."; - import HPA_beat_tracker as beats - reload(beats) - beat_times = beats.estimate_beats(xharmony,resample_rate,startbpm,beat_tightness); - - - return xharmony, semisoff, resample_rate, beat_times - -def cal_hamming_window(SR, minFreq=220.0, maxFreq=1661.0, resolution_fact=5.0,tuning=0.0): - - # Function: - # [hammingK,half_winLenK,freqBins]=cal_hamming_window(SR, minFreq, maxFreq, resolution_fact,tuning) - # This function computes the hamming window for the constant Q transformation. - # - # INPUTS - # SR - the sample rate - # minFreq - the lowest frequency (e.g. 55HZ) - # maxFreq - the highest frequency (e.g. 1661HZ) - # resolution_fact - the resolution of Q (Q_new=Q_org*resolution) - # tuning - tuning parameter, fk=fk*2^(tuning/bins) - # - # OUTPUTS - # hammingK - the hamming windows for each frequency - # half_winLenK - the half_length of each hamming window k - # freqBins - the frequency of each hamming window - # - # --------------------------------------------- - # Function created by Y. Ni - # Function revised by M. McVicar - # Intelligent Systems Lab - # University of Bristol - # U.K. - # 2011 - - # 1. Configulation - import numpy as np - bins=12; - pitchClass=12; - pitchInterval = int(np.true_divide(bins,pitchClass)); - pitchIntervalMap = np.zeros(bins); - - for i in range(pitchClass): - pitchIntervalMap[(i-1)*pitchInterval+1:i*pitchInterval+1] = int(i+1); - - # 2. Frequency bins - K = int(np.ceil(np.log2(maxFreq/minFreq))*bins); #The number of bins - freqBins = np.zeros(K); - - #semiInterval = np.hstack([-bins_fact/bins, 0, bins_fact/bins]); - - for i in range(0,K-pitchInterval+1,pitchInterval): - octaveIndex = np.floor(np.true_divide(i,bins)); - binIndex = np.mod(i,bins); - val = minFreq*2.0**(octaveIndex+(pitchIntervalMap[binIndex]-1.0)/pitchClass); - freqBins[i:i+pitchInterval+1] = val; - - # Augment using tuning factor - freqBins = freqBins*2.0**(tuning/bins); - - # 3. Constant Q and window size - Q = 1.0/(2.0**(1.0/bins)-1)*resolution_fact; - winLenK = np.ceil(SR*np.true_divide(Q,freqBins)); - - # 4. Construct the hamming window - half_winLenK = winLenK; - const = 1j*-2.0*np.pi*Q - expFactor = np.multiply(const,range(int(winLenK[0])+1)); - expFactor = np.conj(expFactor) - hamming_k = list() - for k in range(K): - N = int(winLenK[k]) - half_winLenK[k] = int(np.ceil(N/2.0)) - hamming_k.append(np.hamming(N)* np.true_divide(np.exp(np.true_divide(expFactor[range(N)],N)),N)); - - return hamming_k, half_winLenK, freqBins - -def cal_CQ_chroma_loudness(x,SR, beat_times, hammingK, half_winLenK, freqK, refLabel='s', A_weightLabel=1,q_value=0,normFlag='n'): - - # Function: - # - # [chromagram,normal_chromagram,sample_times]=cal_CQ_chroma_loudness(x,SR,... - # beat_times, hammingK, half_winLenK, freqK, refLabel, A_weightLabel,q_value,normFlag) - # - # Main function to compute the loudness based beat-sync (or fixed length) chromagram features - # - # INPUTS - # x - the wave signal (from wavread) - # SR - the sample rate - # beat_time - the beat time (unit: second) - # hammingK - the hamming windows for each frequency - # half_winLenK - the half_length of each hamming window k - # freqK - the k'th frequency - # (Computed by .m function: cal_hamming_window) - # refLabel - the reference label, 'n': no reference (i.e. 1); - # 's':the standard human perceivable level, 10^(-12) - # 'mean':related to the average loudness of the song (i.e. ref=mean(power sequence)); - # 'median':related to the average loudness of the song (i.e. ref=median(power sequence)); - # 'q':using the q-quantile power as the reference (need 0<=q_value<=1) - # (i.e. regarding q_value percent of the frames as slience) - # A_weightLabel - 1:using A weighting; 0:otherwise - # Remark: A-weighting is a scaling curve on the amplitude spectrum, see - # http://en.wikipedia.org/wiki/A-weighting - # q_value - used in q-quantile reference - # normFlag - 'n': normal features and normalization used is: frame=(frame-min(frame))/(max(frame)-min(frame)) - # 's': shift version, loudness=10*log10(power/ref+1); - # normalization used is L1 norm: frame=frame/max(frame) - # - # OUTPUTS - # chromagram - the loudness based chromagram features (length Nb+1) - # normal_chromagram - the normalized loudness chromagram features (length Nb+1) - # sample_times - the sample times for each frame, formated as a Nx2 matrix [start_times,end_times] - # - # --------------------------------------------- - # Function created by Y. Ni - # Function revised by M. McVicar - # Intelligent Systems Lab - # University of Bristol - # U.K. - # 2011 - # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - - # 1. configulation - import numpy as np - bins = 12; - Nxorig = len(x); - x = np.hstack([x,np.zeros(2.0**np.ceil(np.log2(Nxorig))-Nxorig)]); # Add the end to make the length to be 2^N - Nx = len(x); - K = len(hammingK); #The number of frequency bins - xf = np.fft.fft(x); - - # special: check whether hamming window length is > length(xf)%%%%%%%%%%%%% - warningFlag = np.zeros(K); - for k in range(K): - if (len(hammingK[k])>Nx): - print('In function cal_CQ_chroma_loudness: certain hamming winow is wider than the music itself.'); - warningFlag[k]=1; - - # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - - - # %1.1 The beat-time interva - beatSR = np.ceil(np.multiply(beat_times,SR)); # Get the beat time (transform it into sample indices) - beatSR = np.delete(beatSR, np.nonzero(beatSR>=Nxorig)) #delete those samples that have exceeded the end of the song - - if beatSR[0] is 0: - beatSR = np.hstack([beatSR, Nxorig]); - else: - beatSR = np.hstack([0.0, beatSR, Nxorig]); - - numF=len(beatSR)-1; - - # %1.2 reference label - if refLabel is 'n': - refPower = 1; - elif refLabel is 's': - refPower=10.0**(-12.0) - elif refLabel is 'mean': - meanPowerK = np.zeros(K); - elif refLabel is 'median': - medianPowerK = np.zeros(K) - elif refLabel is 'q': - quantile_matrix = np.zeros(Nxorig); # Store the average power of each frame - if (q_value<0.0 or q_value>1.0): - print('Error in cal_CQ_chroma_loudness: the q value exceeds boundaries.'); - else: - print('Error in cal_CQ_chroma_loudness: can not find the reference label.'); - - # %1.3 A-weight parameters - if A_weightLabel is 1: - Ap1 = 12200.0**2.0; - Ap2 = 20.6**2.0; - Ap3 = 107.7**2.0; - Ap4 = 737.9**2.0; - - # %2. Compute the CQ matrix for each point (row) and each frequency bin (column) - A_offsets = np.zeros(K); - CQ = np.zeros([K,numF]); - if normFlag is 's': #shifted chromagram - for k in range(K): - # 2.1. Get the constant Q tranformation - half_len = int(half_winLenK[k]) - w = np.hstack([hammingK[k][half_len-1:], np.zeros(Nx-len(hammingK[k])), hammingK[k][:half_len-1]]); - wf = np.fft.fft(w); - if warningFlag[k] is 1: - xft = np.hstack([xf,np.zeros(len(wf)-len(xf))]); - convolf = xft*wf; - else: - convolf = xf*wf; - - convol = np.fft.ifft(convolf); - - # 2.2. A-weighting - if A_weightLabel is 1: - frequency_k2 = freqK[k]**2.0; - A_scale = Ap1*frequency_k2**2.0/((frequency_k2+Ap2)*np.sqrt((frequency_k2+Ap3)*(frequency_k2+Ap4))*(frequency_k2+Ap1)); - A_offsets[k] = 2.0+20.0*np.log10(A_scale); - - # 2.3. Reference power and A weighting - if refLabel is 'mean': - convol = np.abs(convol[:Nxorig])**2.0; - meanPowerK[k] = np.mean(convol); - elif refLabel is 'median': - convol = np.abs(convol[:Nxorig])**2.0; - medianPowerK[k] = np.median(convol); - elif refLabel is 'q': - convol = np.abs(convol[:Nxorig])**2.0; - quantile_matrix = np.add(quantile_matrix,convol); - else: - convol = (np.abs(convol[:Nxorig]))**2.0; - - # 2.4. Get the beat interval (median) - for t in range(numF): - t1 = int(beatSR[t])+1 - t2 = int(beatSR[t+1]) - CQ[k,t] = np.median(convol[t1-1:t2]); - - # 2.5 Add the reference power (for mean/median/q-quantiles) - if refLabel is 'mean': - refPower = np.mean(meanPowerK); - temp_one = 10.0*np.log10(np.add(refPower,CQ)) - temp_two = -10*np.log10(refPower) - temp_three = np.transpose(np.tile(A_offsets,(numF,1))); - CQ = np.add(np.add(temp_one,temp_two),temp_three) - elif refLabel is 'median': - refPower = np.median(medianPowerK); - temp_one = 10.0*np.log10(np.add(refPower,CQ)) - temp_two = -10*np.log10(refPower) - temp_three = np.transpose(np.tile(A_offsets,(numF,1))); - CQ = np.add(np.add(temp_one,temp_two),temp_three) - elif refLabel is 'q': - quantile_value = np.sort(quantile_matrix); # sort the values, set reference as the value that falls in the q_value%-th of examples - refPower = quantile_value[int(np.floor(q_value*Nxorig))-1]/K; - temp_one = 10.0*np.log10(np.add(refPower,CQ)) - temp_two = -10*np.log10(refPower) - temp_three = np.transpose(np.tile(A_offsets,(numF,1))); - CQ = np.add(np.add(temp_one,temp_two),temp_three) - else: - temp_one = 10.0*np.log10(np.add(refPower,CQ)) - temp_two = -10*np.log10(refPower) - temp_three = np.transpose(np.tile(A_offsets,(numF,1))); - CQ = np.add(np.add(temp_one,temp_two),temp_three) - - # 3. Computer the beat sync-ed chromagram - chromagram = np.zeros((bins,numF)); - normal_chromagram = np.zeros((bins,numF)); - - for i in range(bins): - chromagram[i,:] = np.sum(CQ[i::bins,:],0); - - # 4. Compute the normalized chromagram features (L1 norm) - for i in range(chromagram.shape[1]): - temp_max = np.max(chromagram[:,i]); - if (temp_max>0.0): - normal_chromagram[:,i] = np.true_divide(chromagram[:,i],temp_max); - - elif normFlag is 'n': #normal chromagram - for k in range(K): - # 2.1. Get the constant Q tranformation - half_len = int(half_winLenK[k]) - w = np.hstack([hammingK[k][half_len-1:], np.zeros(Nx-len(hammingK[k])), hammingK[k][:half_len-1]]); - wf = np.fft.fft(w); - convolf = xf*wf; - convol = np.fft.ifft(convolf); - - # 2.2. A-weighting - if A_weightLabel is 1: - frequency_k2 = freqK[k]**2.0; - A_scale = Ap1*frequency_k2**2.0/((frequency_k2+Ap2)*np.sqrt((frequency_k2+Ap3)*(frequency_k2+Ap4))*(frequency_k2+Ap1)); - A_offsets[k] = 2.0+20.0*np.log10(A_scale); - - - # 2.3. Reference power and A weighting - if refLabel is 'mean': - convol = np.abs(convol[:Nxorig])**2.0; - meanPowerK[k] = np.mean(convol); - elif refLabel is 'median': - convol = np.abs(convol[:Nxorig])**2.0; - medianPowerK[k] = np.median(convol); - elif refLabel is 'q': - convol = np.abs(convol[:Nxorig])**2.0; - quantile_matrix = np.add(quantile_matrix,convol); - else: - convol = (np.abs(convol[:Nxorig]))**2.0; - - # 2.4. Get the beat interval (median) - for t in range(numF): - t1 = int(beatSR[t])+1 - t2 = int(beatSR[t+1]) - CQ[k,t] = np.median(convol[t1-1:t2]); - - # 2.5 Add the reference power (for mean/median/q-quantiles) - if refLabel is 'mean': - refPower = np.mean(meanPowerK); - CQ = np.add(10.0*np.log10(CQ),-10.0*np.log10(refPower)) - CQ = np.add(CQ,np.transpose(np.tile(A_offsets,(numF,1)))); - elif refLabel is 'median': - refPower = np.median(medianPowerK); - CQ = np.add(10.0*np.log10(CQ),-10.0*np.log10(refPower)) - CQ = np.add(CQ,np.transpose(np.tile(A_offsets,(numF,1)))); - elif refLabel is 'q': - quantile_value = np.sort(quantile_matrix); # sort the values, set reference as the value that falls in the q_value%-th of examples - refPower = quantile_value[int(np.floor(q_value*Nxorig))-1]/K; - CQ = np.add(10.0*np.log10(CQ),-10*np.log10(refPower)) - CQ = np.add(CQ,np.transpose(np.tile(A_offsets,(numF,1)))); - else: - CQ = np.add(10.0*np.log10(CQ),-10.0*np.log10(refPower)) - CQ = np.add(CQ,np.transpose(np.tile(A_offsets,(numF,1)))); - - # 3. Computer the beat sync-ed chromagram - chromagram = np.zeros((bins,numF)); - normal_chromagram = np.zeros((bins,numF)); - - for i in range(bins): - chromagram[i,:] = np.sum(CQ[i::bins,:],0); - - - # 4. Compute the normalized chromagram features (Linear norm) - for i in range(chromagram.shape[1]): - maxCol = np.max(chromagram[:,i]); - minCol = np.min(chromagram[:,i]); - if (maxCol>minCol): - normal_chromagram[:,i] = np.true_divide((chromagram[:,i]-minCol),(maxCol-minCol)); - else: - normal_chromagram[:,i] = 0.0; - else: - print('Error in cal_CQ_chroma_loudness: no such normFlag.'); - - # Do the circle shift - shift_pos = round(12.0*np.log2(freqK[0]/27.5)); # The relative position to A0 - shift_pos = int(np.mod(shift_pos,12)-3); # since A0 should shift -3 - if not (shift_pos is 0): - chromagram = np.roll(chromagram,shift_pos,0); - normal_chromagram = np.roll(normal_chromagram,shift_pos,0); - - # 5. return the sample times - beatSR = beatSR/SR; - sample_times = np.vstack([beatSR[:-1], beatSR[1:]]); - - return chromagram, normal_chromagram, sample_times - -def write_wave(x,fname,frate,nchannels): - - # Writes the wavefile in x to fname at frate frames/s and nchannes - import wave - import struct - import numpy as np - - amp = 64000.0 - wav_file = wave.open(fname, "w") - - sampwidth = 2 - framerate = int(frate) - nframes = len(x); - comptype = "NONE" - compname = "not compressed" - - # normalise - x = np.true_divide(x,max(abs(x))); - - wav_file.setparams((nchannels, sampwidth, framerate, nframes, - comptype, compname)) - - for s in x: - # write the audio frames to file - wav_file.writeframes(struct.pack('h', int(s*amp/2))) - - wav_file.close() diff --git a/librosa/FeatureExtraction/HPA_stftistft.py b/librosa/FeatureExtraction/HPA_stftistft.py deleted file mode 100644 index 0cce57b2a5..0000000000 --- a/librosa/FeatureExtraction/HPA_stftistft.py +++ /dev/null @@ -1,95 +0,0 @@ -def stft(x, f, w, h): - # D = stft(X, F, W, H) - # Short-time Fourier transform. - # Returns some frames of short-term Fourier transform of x. Each - # column of the result is one F-point fft; each successive frame is - # offset by H points until X is exhausted. Data is hamm-windowed - # at W pts, or rectangular if W=0, or with W if it is a vector. - # See also 'istft.m'. - # dpwe 1994may05. Uses built-in 'fft' - # $Header: /homes/dpwe/public_html/resources/matlab/pvoc/RCS/stft.m,v 1.2 2009/01/07 04:32:42 dpwe Exp $ - - d = 0; - s = len(x); - - # sort out window types - import numpy as np - if type(w) is int: - if w == 0: - # special case: rectangular window - win = np.ones(f); - else: - if (w % 2) == 0: # force window to be odd-len - w = w + 1; - halflen = int((w-1)/2.0); - halff = int(f/2.0); # midpoint of win - halfwin = 0.5*(1+np.cos(np.pi*np.true_divide(range(halflen+1),halflen))) - win = np.zeros(f); - acthalflen = min(halff, halflen); - win[range(halff,halff+acthalflen)] = halfwin[range(acthalflen)]; - win[range(halff,halff-acthalflen,-1)] = halfwin[range(acthalflen)]; - else: - win = w; - w = len(w); - - c = 0; - # pre-allocate output array - d = np.zeros(((1+f/2.0),1+np.floor((s-f)/h)),dtype=complex); - - for b in range(0,s-f+1,h): - u = win*x[range(b,b+f)]; - t = np.fft.fft(u); - d[:,c] = t[range(1+int(f/2.0))]; - c = c+1; - - return d - -def istft(d, ftsize, w, h): - # Function: - # X = istft(D, F, W, H) - # Inverse short-time Fourier transform. - # Performs overlap-add resynthesis from the short-time Fourier transform - # data in D. Each column of D is taken as the result of an F-point - # fft; each successive frame was offset by H points. Data is - # hamm-windowed at W pts. - # W = 0 gives a rectangular window; W as a vector uses that as window. - # dpwe 1994may24. Uses built-in 'ifft' etc. - # $Header: /homes/dpwe/public_html/resources/matlab/pvoc/RCS/istft.m,v 1.4 2009/01/07 04:20:00 dpwe Exp $ - - s = d.shape; - cols = s[1]; - xlen = ftsize + (cols-1)*h; - import numpy as np - x = np.zeros(xlen); - - # sort out window types - if type(w) is int: - if w == 0: - # special case: rectangular window - win = np.ones(ftsize); - else: - if (w % 2) == 0: # force window to be odd-len - w = w + 1; - halflen = int((w-1)/2.0); - halff = int(ftsize/2.0); # midpoint of win - halfwin = 0.5*(1+np.cos(np.pi*np.true_divide(range(halflen+1),halflen))) - win = np.zeros(ftsize); - acthalflen = min(halff, halflen); - win[range(halff,halff+acthalflen)] = halfwin[range(acthalflen)]; - win[range(halff,halff-acthalflen,-1)] = halfwin[range(acthalflen)]; - # 2009-01-06: Make stft-istft loop be identity - win = np.true_divide(2.0*win,3.0); - else: - win = w; - w = len(w); - - # Grab the ifft of each column, weighted by win - for b in range(0,(h*(cols-1)),h): - ft = d[:,int(b/h)]; - r = range(int(ftsize/2)-1,0,-1); - part_two = np.conj(ft[r]); - ft = np.hstack([ft,part_two]); - px = np.real(np.fft.ifft(ft)); - x[range(b,b+ftsize)] = x[range(b,b+ftsize)]+px*win; - - return x diff --git a/librosa/FeatureExtraction/HPA_test.py b/librosa/FeatureExtraction/HPA_test.py deleted file mode 100644 index 7960207c40..0000000000 --- a/librosa/FeatureExtraction/HPA_test.py +++ /dev/null @@ -1,21 +0,0 @@ -# Test script for chromagram extraction. Set paths and exrtact chroma. Also time - -import os -os.chdir("/Users/mattmcvicar/Desktop/Work/HPA_python_1.0") - -import sys -sys.path.append("/Users/mattmcvicar/Desktop/Work/HPA_python_1.0/FeatureExtraction") - -# Name of wavefile to analyse -filename = '/Users/mattmcvicar/Desktop/Work/Python_stuff/chroma_extraction/pianoa4.wav'; - -import time - -import HPA_extract_chroma as chromagram -reload(chromagram) -t1 = time.time() -[chroma, normal_chroma, sample_times, tuning] = chromagram.extract_chroma(filename) -t2 = time.time() - -print 'chromagram extraction finished in %0.3f' % ((t2-t1)) -print normal_chroma diff --git a/librosa/FeatureExtraction/HPA_tuning.py b/librosa/FeatureExtraction/HPA_tuning.py deleted file mode 100644 index f0a8b2817d..0000000000 --- a/librosa/FeatureExtraction/HPA_tuning.py +++ /dev/null @@ -1,297 +0,0 @@ -def estimate_tuning(d,sr,fftlen,f_ctr,f_sd): - - # Get minimum/maximum frequencies - fminl = octs2hz(hz2octs(f_ctr)-2*f_sd); - fminu = octs2hz(hz2octs(f_ctr)-f_sd); - fmaxl = octs2hz(hz2octs(f_ctr)+f_sd); - fmaxu = octs2hz(hz2octs(f_ctr)+2*f_sd); - - # Estimte pitches - [p,m,S] = isp_ifptrack(d,fftlen,sr,fminl,fminu,fmaxl,fmaxu) - - # nzp=linear index of non-zero sinusoids found. - nzp = p.flatten(1)>0; - - #Find significantly large magnitudes - import numpy as np - mflat = m.flatten(1); - gmm = mflat > np.median(mflat[nzp]) - - # 2. element-multiply large magnitudes with frequencies. - nzp = nzp * gmm; - - # get non-zero again. - nzp = np.nonzero(nzp)[0]; - - # 3. convert to octaves - #Pocts=p.copy(); not used - pflat = p.flatten(1); - - # I didn't bother vectorising hz2octs....do it in a loop - temp_hz = pflat[nzp]; - for i in range(len(temp_hz)): - temp_hz[i] = hz2octs(temp_hz[i]); - - Poctsflat = p.flatten(1); - Poctsflat[nzp] = temp_hz; - to_count = Poctsflat[nzp]; - - # 4. get tuning - nchr=12; # size of feature - - # make histogram, resolution is 0.01, from -0.5 to 0.5 - import matplotlib.pyplot as plt - term_one = nchr*to_count; - term_two = np.array(np.round(nchr*to_count),dtype=np.int) - bins = [xxx * 0.01 for xxx in range(-50, 51)]; - - # python uses edges, matlab uses centers so subtract half a bin size - z = plt.hist(term_one-term_two-0.005,bins); - - hn = z[0]; - hx = z[1]; - - # prepend things less than min - nless = [sum(term_one-term_two-0.005 < -0.5)] - hn = np.hstack([nless,hn]); - - # find peaks - semisoff = hx[np.argmax(hn)]; - - return semisoff - -def hz2octs(freq, A = 440.0): - - # Convert a frequency in Hz into a real number counting - # the octaves above A0. So hz2octs(440) = 4.0 - # Optional A440 specifies the Hz to be treated as middle A (default 440). - # 2006-06-29 dpwe@ee.columbia.edu for fft2chromamx - - # A4 = A440 = 440 Hz, so A0 = 440/16 Hz - import numpy as np - octs = np.log(freq/(A/16))/np.log(2); - return octs - - -def octs2hz(octs, A = 440.0): - - #hz = octs2hz(octs,A440) - #Convert a real-number octave - #into a frequency in Hzfrequency in Hz into a real number counting - #the octaves above A0. So hz2octs(440) = 4.0. - #Optional A440 specifies the Hz to be treated as middle A (default 440). - #2006-06-29 dpwe@ee.columbia.edu for fft2chromamx - - #A4 = A440 = 440 Hz, so A0 = 440/16 Hz - hz = (A/16)*(2**octs); - return hz - -def isp_ifptrack(d,w,sr,fminl = 150.0, fminu = 300.0, fmaxl = 2000.0, fmaxu = 4000.0): - - # DESCRIPTION - # Track pitch based on instantaneous frequency. It looks for adjacent - # bins with same inst freq. - # INPUT - # d: - # Input waveform. - # w: - # STFT DFT length (window is half, hop is 1/4). - # sr: - # Sample rate. - # fminl, fmaxu, fmaxl, fmaxu: - # Define ramps at edge of sensitivity. - # - # OUTPUT - # p: - # Tracked pitch frequencies. - # m: - # Tracked pitch magnitudes. - # S: - # The underlying complex STFT. - - # Only look at bins up to 2 kHz - maxbin = int(round(fmaxu*float(w)/float(sr))); - #minbin = int(round(fminl*float(w)/float(sr))); not used - - # Calculate the inst freq gram - [I,S] = isp_ifgram(d,w,w/2,w/4,sr, maxbin); - - # Find plateaus in ifgram - stretches where delta IF is < thr - import numpy as np - ddif = I[np.hstack([range(1,maxbin),maxbin-1]),:]-I[np.hstack([0,range(0,maxbin-1)]),:]; - - # expected increment per bin = sr/w, threshold at 3/4 that - dgood = abs(ddif) < .75*float(sr)/float(w); - - # delete any single bins (both above and below are zero); - logic_one = dgood[np.hstack([range(1,maxbin),maxbin-1]),:] > 0; - logic_two = dgood[np.hstack([0,range(0,maxbin-1)]),:] > 0; - dgood = dgood * np.logical_or(logic_one,logic_two); - - p = np.zeros(dgood.shape); - m = np.zeros(dgood.shape); - - # For each frame, extract all harmonic freqs & magnitudes - lds = np.size(dgood,0); - for t in range(I.shape[1]): - ds = dgood[:,t]; - - # find nonzero regions in this vector - logic_one = np.hstack([0,ds[range(0,lds-1)]])==0; - logic_two = ds > 0; - logic_oneandtwo = np.logical_and(logic_one,logic_two); - st = np.nonzero(logic_oneandtwo)[0]; - - logic_three = np.hstack([ds[range(1,lds)],0])==0; - logic_twoandthree = np.logical_and(logic_two,logic_three); - en = np.nonzero(logic_twoandthree)[0]; - - # Set up inner loop - npks = len(st); - frqs = np.zeros(npks); - mags = np.zeros(npks); - for i in range(len(st)): - bump = np.abs(S[range(st[i],en[i]+1),t]); - mags[i] = sum(bump); - - # another long division, split it up - numer = np.dot(bump,I[range(st[i],en[i]+1),t]); - isz = (mags[i]==0); - denom = mags[i]+isz.astype(int); - frqs[i] = numer/denom; - - if frqs[i] > fmaxu: - mags[i] = 0; - frqs[i] = 0; - elif frqs[i] > fmaxl: - mags[i] = mags[i] * max(0, (fmaxu - frqs[i])/(fmaxu-fmaxl)); - - # downweight magnitudes below? 200 Hz - if frqs[i] < fminl: - mags[i] = 0; - frqs[i] = 0; - elif frqs[i] < fminu: - # 1 octave fade-out - mags[i] = mags[i] * (frqs[i] - fminl)/(fminu-fminl); - - if frqs[i] < 0: - mags[i] = 0; - frqs[i] = 0; - - # Collect into bins - bin = np.round((st+en)/2.0); - p[bin.astype(int),t] = frqs; - m[bin.astype(int),t] = mags; - - return p,m,S - -def isp_ifgram(X, N=256, W=256, H=256.0/2.0, SR=1, maxbin=1.0+256.0/2.0): - - # SYNTAX - # [F,D] = ifgram(X, N, W, H, SR, maxbin) - # - # DESCRIPTION - # Compute the instantaneous frequency (as a proportion of the sampling - # rate) obtained as the time-derivative of the phase of the complex - # spectrum as described by Toshihiro Abe et al in ICASSP'95, - # Eurospeech'97. Calculates regular STFT as side effect. - # - # INPUT - # X: - # Wave signal. - # N: - # FFT length. - # W: - # Window length. - # H: - # Step length. - # SR: - # Sampling rate. - # maxbin: - # The index of the maximum bin needed. If specified, unnecessary - # computations are skipped. - # OUTPUT - # F: - # Instantaneous frequency spectrogram. - # D: - # Short time Fourier transform spectrogram. - - Flen = maxbin; - s = X.size; - - # Make a Hanning window - import numpy as np - win = 0.5*(1-np.cos(np.true_divide(np.arange(W)*2*np.pi,W))); - - # Window for discrete differentiation - T = float(W)/float(SR); - dwin = (-np.pi/T)*np.sin(np.true_divide(np.arange(W)*2*np.pi,W)); - - # sum(win) takes out integration due to window, 2 compensates for neg frq - norm = 2/sum(win); - - # How many complete windows? - import math - nhops = 1 + int(math.floor((s - W)/H)); - - F = np.zeros((Flen, nhops)); - D = np.zeros((Flen, nhops),dtype=complex); - - nmw1 = int(math.floor((N-W)/2)); - - ww = 2*np.pi*np.arange(Flen)*SR/N; - - wu = np.zeros(N); - du = np.zeros(N); - - # Main loop - for h in range(nhops): - u = X[h*H:(W+h*H)]; - - # Pad or truncate samples if N != W - # Apply windows now, while the length is right - if N >= W: - wu[nmw1:(nmw1+W)] = win*u; - du[nmw1:(nmw1+W)] = dwin*u; - elif N < W: - # Can't make sense of Dan's code here: - #wu = win[1-nmw1:N-nmw1]*u[1-nmw1:N-nmw1]; - #du = dwin[1-nmw1:N-nmw1]*u[1-nmw1:N-nmw1]; - print 'Error, N must be at least window size' - - # FFTs of straight samples plus differential-weighted ones - # Replaced call to fftshift with inline version. Jesper Hjvang Jensen, Aug 2007 - # t1 = fft(fftshift(du)); - # t2 = fft(fftshift(wu)); - split = int(math.ceil(du.size/2.0) + 1); - - # Need to reverse front and last parts of du and wu - temp_du = np.hstack([du[split-1:],du[0:split-1]]); - temp_wu = np.hstack([wu[split-1:],wu[0:split-1]]); - - t1 = np.fft.fft(temp_du); - t2 = np.fft.fft(temp_wu); - - t1 = t1[0:Flen]; - t2 = t2[0:Flen]; - - # Scale down to factor out length & window effects - D[:,h] = t2*norm; - - # Calculate instantaneous frequency from phase of differential spectrum - t = t1 + 1j*(ww*t2); - a = t2.real; - b = t2.imag; - da = t.real; - db = t.imag; - - # split this confusing divsion into chunks! - # instf = (1/(2*pi))*(a.*db - b.*da)./((a.*a + b.*b)+(t2==0)); - num_one = 1.0/(2*np.pi); - num_two = (a*db - b*da); - denom_one = (a*a + b*b); - isz = (t2==0); - instf = np.true_divide(num_one*num_two,denom_one+isz.astype(int)); - F[:,h] = instf; - - return F, D diff --git a/librosa/__init__.py b/librosa/__init__.py index a1ff9251e5..8eef3d8b4a 100644 --- a/librosa/__init__.py +++ b/librosa/__init__.py @@ -1,496 +1,34 @@ #!/usr/bin/env python -''' -CREATED:2012-10-20 11:09:30 by Brian McFee +# -*- coding: utf-8 -*- +"""Top-level module for librosa""" -Top-level class for librosa +import warnings +import re +warnings.filterwarnings('always', + category=DeprecationWarning, + module='^{0}'.format(re.escape(__name__))) -Includes constants, core utility functions, etc - -''' - -import numpy, scipy, scipy.signal -import os.path -import audioread +from .version import version as __version__ # And all the librosa sub-modules -import beat, framegenerator, chroma, tf_agc, output, hpss - -def load(path, target_sr=22050, mono=True): - ''' - Load an audio file into a single, long time series - - Input: - path: path to the input file - target_sr: target sample rate | default: 22050 - | specify None to use the file's native sampling rate - mono: convert to mono? | default: True - - Output: - y: the time series - sr: the sampling rate - ''' - - with audioread.audio_open(os.path.realpath(path)) as f: - sr = f.samplerate - y = [numpy.frombuffer(frame, ' 1: - if mono: - y = 0.5 * (y[::2] + y[1::2]) - else: - y = y.reshape( (-1, 2)).T - pass - pass - pass - - if target_sr is not None: - return (resample(y, sr, target_sr), target_sr) - - return (y, sr) - -def resample(y, orig_sr, target_sr): - ''' - Resample a signal from orig_sr to target_sr - - Input: - y: time series (either mono or stereo) - orig_sr: original sample rate of y - target_sr: target sample rate - - Output: - y_hat: resampled signal - ''' - - if orig_sr == target_sr: - return y - - axis = y.ndim-1 - - n_samples = len(y) * target_sr / orig_sr - - y_hat = scipy.signal.resample(y, n_samples, axis=axis) - - return y_hat - -def pad(w, d_pad, v=0.0, center=True): - ''' - Pad a vector w out to d dimensions, using value v - - if center is True, w will be centered in the output vector - otherwise, w will be at the beginning - ''' - # FIXME: 2012-11-27 11:08:54 by Brian McFee - # This function will be deprecated by numpy 1.7.0 - - d = len(w) - if d > d_pad: - raise ValueError('Insufficient pad space') - - q = v * numpy.ones(d_pad) - q[:d] = w - - if center: - q = numpy.roll(q, numpy.floor((d_pad - d) / 2.0).astype(int), axis=0) - pass - return q - - - -def stft(y, sr=22050, n_fft=256, hann_w=None, hop_length=None): - ''' - Short-time fourier transform - - Inputs: - y = the input signal - sr = sampling rate of y | default: 22050 - n_fft = the number of FFT components | default: 256 - hann_w = size of hann window | default: = n_fft - hop_length = hop length | default: = hann_w / 2 - - Output: - D = complex-valued STFT matrix of y - ''' - num_samples = len(y) - - if hann_w is None: - hann_w = n_fft - pass - - if hann_w == 0: - window = numpy.ones((n_fft,)) - else: - window = pad(scipy.signal.hanning(hann_w), n_fft) - pass - - # Set the default hop, if it's not already specified - if hop_length is None: - hop_length = int(window.shape[0] / 2.0) - pass - - # allocate output array - D = numpy.zeros( (int(1 + n_fft / 2.0), 1 + int( ( num_samples - n_fft) / hop_length) ), dtype=numpy.complex) - - for (i, b) in enumerate(xrange(0, 1+num_samples - n_fft, hop_length)): - u = window * y[b:(b+n_fft)] - t = scipy.fft(u) - D[:,i] = t[:1+n_fft/2] - pass - - return D - - -def istft(d, n_fft=None, hann_w=None, hop_length=None): - ''' - Inverse short-time fourier transform - - Inputs: - d = STFT matrix - n_fft = number of FFT components | default: 2 * (d.shape[0] -1 - hann_w = size of hann window | default: n_fft - hop_length = hop length | default: hann_w / 2 - - Outputs: - y = time domain signal reconstructed from d - ''' - num_frames = d.shape[1] - - if n_fft is None: - n_fft = 2 * (d.shape[0] - 1) - pass - - if hann_w is None: - hann_w = n_fft - pass - - if hann_w == 0: - window = numpy.ones((n_fft,)) - else: - # FIXME: 2012-10-20 18:58:56 by Brian McFee - # there's a magic number 2/3 in istft.m ... not sure about this one - window = pad(scipy.signal.hanning(hann_w) * 2.0 / 3, n_fft) - pass - - # Set the default hop, if it's not already specified - if hop_length is None: - hop_length = int(window.shape[0] / 2.0 ) - pass - - x_length = n_fft + (num_frames - 1) * hop_length - x = numpy.zeros((x_length,)) - - for b in xrange(0, hop_length * (num_frames), hop_length): - ft = d[:, b/hop_length] - ft = numpy.concatenate((ft, numpy.conj(ft[(n_fft/2 -1):0:-1])), 0) - px = numpy.real(scipy.ifft(ft)) - x[b:(b+n_fft)] += px * window - pass - - return x - -# Dead-simple mel spectrum conversion -def hz_to_mel(f, htk=False): - # TODO: 2012-11-27 11:28:43 by Brian McFee - # too many magic numbers in these functions - # redo with informative variable names - # then make them into parameters - ''' - Convert Hz to Mels - - Input: - f: scalar or array of frequencies - htk: use HTK mel conversion instead of Slaney | False - - Output: - m: input frequencies f in Mels - ''' - - if numpy.isscalar(f): - f = numpy.array([f],dtype=float) - pass - if htk: - return 2595.0 * numpy.log10(1.0 + f / 700.0) - else: - f = f.astype(float) - # Oppan Slaney style - f_0 = 0.0 - f_sp = 200.0 / 3 - brkfrq = 1000.0 - brkpt = (brkfrq - f_0) / f_sp - logstep = numpy.exp(numpy.log(6.4) / 27.0) - linpts = f < brkfrq - - nlinpts = numpy.invert(linpts) - - z = numpy.zeros_like(f) - # Fill in parts separately - z[linpts] = (f[linpts] - f_0) / f_sp - z[nlinpts] = brkpt + numpy.log(f[nlinpts] / brkfrq) / numpy.log(logstep) - return z - pass - -def mel_to_hz(z, htk=False): - if numpy.isscalar(z): - z = numpy.array([z], dtype=float) - pass - if htk: - return 700.0 * (10.0**(z / 2595.0) - 1.0) - else: - z = z.astype(float) - f_0 = 0.0 - f_sp = 200.0 / 3 - brkfrq = 1000 - brkpt = (brkfrq - f_0) / f_sp - logstep = numpy.exp(numpy.log(6.4) / 27.0) - f = numpy.zeros_like(z) - linpts = z < brkpt - nlinpts = numpy.invert(linpts) - - f[linpts] = f_0 + f_sp * z[linpts] - f[nlinpts] = brkfrq * numpy.exp(numpy.log(logstep) * (z[nlinpts]-brkpt)) - return f - pass - - -def dctfb(nfilts, d): - ''' - Build a discrete cosine transform basis - - Input: - nfilts : number of output components - d : number of input components - - Output: - D : nfilts-by-d DCT matrix - ''' - DCT = numpy.empty((nfilts, d)) - - q = numpy.arange(1, 2*d, 2) * numpy.pi / (2.0 * d) - DCT[0,:] = 1.0 / numpy.sqrt(d) - for i in xrange(1,nfilts): - DCT[i,:] = numpy.cos(i*q) * numpy.sqrt(2.0/d) - pass - - return DCT - - -def mfcc(S, d=20): - ''' - Mel-frequency cepstral coefficients - - Input: - S : k-by-n log-amplitude spectrogram - d : number of MFCCs to return | default: 20 - Output: - M : d-by-n MFCC sequence - ''' - - return numpy.dot(dctfb(d, S.shape[0]), S) - -# Stolen from ronw's mfcc.py -# https://github.com/ronw/frontend/blob/master/mfcc.py -def melfb(samplerate, nfft, nfilts=40, width=1.0, fmin=None, fmax=None, use_htk=False): - """Create a Filterbank matrix to combine FFT bins into Mel-frequency bins. - - Parameters - ---------- - samplerate : int - Sampling rate of the incoming signal. - nfft : int - FFT length to use. - nfilts : int - Number of Mel bands to use. Defaults to 40. - width : float - The constant width of each band relative to standard Mel. Defaults 1.0 - fmin : float - Frequency in Hz of the lowest edge of the Mel bands. Defaults to 0. - fmax : float - Frequency in Hz of the upper edge of the Mel bands. Defaults - to `samplerate` / 2. - use_htk: bool - Use HTK mels instead of Slaney's version? Defaults to false. - - See Also - -------- - Filterbank - MelSpec - """ - - if fmin is None: - fmin = 0 - pass - - if fmax is None: - fmax = samplerate / 2.0 - pass - - # Initialize the weights - wts = numpy.zeros( (nfilts, nfft) ) - - # Center freqs of each FFT bin - fftfreqs = numpy.arange( wts.shape[1], dtype=numpy.double ) / nfft * samplerate - - # 'Center freqs' of mel bands - uniformly spaced between limits - minmel = hz_to_mel(fmin, htk=use_htk) - maxmel = hz_to_mel(fmax, htk=use_htk) - binfreqs = mel_to_hz(numpy.arange(minmel, minmel + nfilts + 2, dtype=float) * (maxmel - minmel) / (nfilts+1.0), htk=use_htk) - - for i in xrange(nfilts): - freqs = binfreqs[range(i, i+3)] - - # scale by width - freqs = freqs[1] + width * (freqs - freqs[1]) - - # lower and upper slopes for all bins - loslope = (fftfreqs - freqs[0]) / (freqs[1] - freqs[0]) - hislope = (freqs[2] - fftfreqs) / (freqs[2] - freqs[1]) - - # .. then intersect them with each other and zero - wts[i,:] = numpy.maximum(0, numpy.minimum(loslope, hislope)) - - pass - - # Slaney-style mel is scaled to be approx constant E per channel - enorm = 2.0 / (binfreqs[2:nfilts+2] - binfreqs[:nfilts]) - wts = numpy.dot(numpy.diag(enorm), wts) - - return wts - -def melspectrogram(y, sr=22050, window_length=256, hop_length=128, mel_channels=40, htk=False, width=1): - ''' - Compute a mel spectrogram from a time series - - Input: - y = the audio signal - sr = the sampling rate of y | default: 22050 - window_length = FFT window size | default: 256 - hop_length = hop size | default: 128 - mel_channels = number of Mel filters to use | default: 40 - htk = use HTK mels instead of Slaney | default: False - width = width of mel bins | default: 1 - - Output: - S = Mel amplitude spectrogram - ''' - - # Compute the STFT - S = stft(y, sr=sr, n_fft=window_length, hann_w=window_length, hop_length=hop_length) - - # Build a Mel filter - M = melfb(sr, window_length, nfilts=mel_channels, width=width, use_htk=htk) - - # Remove everything past the nyquist frequency - M = M[:, :(window_length / 2 + 1)] - - S = numpy.dot(M, numpy.abs(S)) - - return S - -def logamplitude(S, amin=1e-10, gain_threshold=-80.0): - ''' - Log-scale the amplitude of a spectrogram - - Input: - S = the input spectrogram - amin = minimum allowed amplitude | default: 1e-10 - gain_threshold = minimum output value | default: -80 (None to disable) - Output: - D = S in dBs - ''' - - SCALE = 20.0 - D = SCALE * numpy.log10(numpy.maximum(amin, numpy.abs(S))) - - if gain_threshold is not None: - D[D < gain_threshold] = gain_threshold - pass - return D - -def localmax(x): - ''' - Return 1 where there are local maxima in x (column-wise) - left edges do not fire, right edges might. - ''' - - return numpy.logical_and(x > numpy.hstack([x[0], x[:-1]]), x >= numpy.hstack([x[1:], x[-1]])) - - -def autocorrelate(x, max_size=None): - ''' - Bounded auto-correlation - - Input: - x: t-by-1 vector - max_size: (optional) maximum lag | None - - Output: - z: x's autocorrelation (up to max_size if given) - ''' - # TODO: 2012-11-07 14:05:42 by Brian McFee - # maybe could be done faster by directly implementing a clipped correlate -# result = numpy.correlate(x, x, mode='full') - result = scipy.signal.fftconvolve(x, x[::-1], mode='full') - - result = result[len(result)/2:] - if max_size is None: - return result - return result[:max_size] - -def frames_to_time(frames, sr=22050, hop_length=64): - ''' - Converts frame counts to time (seconds) - - Input: - frames: scalar or n-by-1 vector of frame numbers - sr: sampling rate | 22050 Hz - hop_length: hop length of the frames | 64 frames - - Output: - times: time (in seconds) of each given frame number - ''' - return frames * float(hop_length) / float(sr) - -# Stolen from ronw's chroma.py -# https://github.com/ronw/frontend/blob/master/chroma.py -def hz_to_octs(frequencies, A440=440.0): - ''' - Convert frquencies (Hz) to octave numbers - - Input: - frequencies: scalar or vector of frequencies - A440: frequency of A440 (in Hz) | 440.0 - - Output: - octaves: octave number fore each frequency - ''' - return numpy.log2(frequencies / (A440 / 16.0)) - - -def feature_sync(X, F, agg=numpy.mean): - ''' - Synchronous aggregation of a feature matrix - - Input: - X: d-by-T | (dense) feature matrix (eg spectrogram, chromagram, etc) - F: t-vector | (ordered) array of frame numbers - agg: aggregator function | default: numpy.mean - - Output: - Y: d-by-(<=t+1) vector - where - Y[:,i] = agg(X[:, F[i-1]:F[i]], axis=1) - - In order to ensure total coverage, boundary points are added to F - ''' +from . import cache +from . import core +from . import beat +from . import decompose +from . import display +from . import effects +from . import feature +from . import filters +from . import onset +from . import output +from . import segment +from . import util - F = numpy.unique(numpy.concatenate( ([0], F, [X.shape[1]]) )) +# Exporting exception classes at the top level +from .util.exceptions import * # pylint: disable=wildcard-import - Y = numpy.zeros( (X.shape[0], len(F)-1) ) +# Exporting all core functions is okay here: suppress the import warning +from librosa.core import * # pylint: disable=wildcard-import - lb = F[0] - for (i, ub) in enumerate(F[1:]): - Y[:,i] = agg(X[:, lb:ub], axis=1) - lb = ub - pass - return Y diff --git a/librosa/beat.py b/librosa/beat.py index f1833b864c..568562e53a 100644 --- a/librosa/beat.py +++ b/librosa/beat.py @@ -1,331 +1,442 @@ #!/usr/bin/env python -''' -CREATED:2012-11-05 14:38:03 by Brian McFee +# -*- coding: utf-8 -*- +""" +Beat and tempo +============== +.. autosummary:: + :toctree: generated/ -All things rhythmic go here + beat_track + estimate_tempo +""" -- Onset detection -- Tempo estimation -- Beat tracking -- Segmentation +import numpy as np +import scipy -''' +from . import cache +from . import core +from . import onset +from . import util +from .util.exceptions import ParameterError -import librosa -import numpy, scipy, scipy.signal, scipy.ndimage -import sklearn, sklearn.cluster, sklearn.feature_extraction +__all__ = ['beat_track', 'estimate_tempo'] -def beat_track(y, sr=22050, hop_length=256, start_bpm=120.0, tightness=400, onsets=None): - ''' - Ellis-style beat tracker - - Input: - y: time-series data - sr: sample rate of y | default: 22050 - hop_length: hop length (in frames) for onset detection | default: 256 ~= 11.6ms - start_bpm: initial guess for BPM estimator | default: 120.0 - tightness: tightness parameter for tracker | default: 400 - onsets: optional pre-computed onset envelope | default: None - - Output: - bpm: estimated global tempo - beats: array of estimated beats by frame number - ''' - # First, get the frame->beat strength profile if we don't already have one - if onsets is None: - onsets = onset_strength(y, sr, hop_length=hop_length) - pass +def beat_track(y=None, sr=22050, onset_envelope=None, hop_length=512, + start_bpm=120.0, tightness=100, trim=True, bpm=None): + r'''Dynamic programming beat tracker. - # Then, estimate bpm - bpm = onset_estimate_bpm(onsets, start_bpm, sr, hop_length) - - # Then, run the tracker - beats = _beat_tracker(onsets, bpm, sr, hop_length, tightness) + Beats are detected in three stages, following the method of [1]_: + 1. Measure onset strength + 2. Estimate tempo from onset correlation + 3. Pick peaks in onset strength approximately consistent with estimated + tempo - return (bpm, beats) + .. [1] Ellis, Daniel PW. "Beat tracking by dynamic programming." + Journal of New Music Research 36.1 (2007): 51-60. + http://labrosa.ee.columbia.edu/projects/beattrack/ + Parameters + ---------- -def _beat_tracker(onsets, start_bpm, sr, hop_length, tightness): + y : np.ndarray [shape=(n,)] or None + audio time series - fft_resolution = numpy.float(sr) / hop_length - period = int(round(60.0 * fft_resolution / start_bpm)) + sr : number > 0 [scalar] + sampling rate of `y` - # Smooth beat events with a gaussian window - template = numpy.exp(-0.5 * (numpy.linspace(-32, 32+1, 2*period + 1)**2)) + onset_envelope : np.ndarray [shape=(n,)] or None + (optional) pre-computed onset strength envelope. - # Convolve - localscore = scipy.signal.convolve(onsets, template, 'same') - max_localscore = numpy.max(localscore) + hop_length : int > 0 [scalar] + number of audio samples between successive `onset_envelope` values - ### Initialize DP + start_bpm : float > 0 [scalar] + initial guess for the tempo estimator (in beats per minute) - backlink = numpy.zeros_like(localscore, dtype=int) - cumscore = numpy.zeros_like(localscore) + tightness : float [scalar] + tightness of beat distribution around tempo - # Search range for previous beat: number of samples forward/backward to look - search_window = numpy.arange(-2 * period, -numpy.round(period/2) + 1, dtype=int) + trim : bool [scalar] + trim leading/trailing beats with weak onsets - # Make a score window, which begins biased toward start_bpm and skewed - txwt = - tightness * numpy.abs(numpy.log(-search_window) - numpy.log(period))**2 + bpm : float [scalar] + (optional) If provided, use `bpm` as the tempo instead of + estimating it from `onsets`. - # Are we on the first beat? - first_beat = True - time_range = search_window - # Forward step - for i in xrange(len(localscore)): + Returns + ------- - # Are we reaching back before time 0? - z_pad = numpy.maximum(0, numpy.minimum(- time_range[0], len(search_window))) + tempo : float [scalar, non-negative] + estimated global tempo (in beats per minute) - # Search over all possible predecessors and apply transition weighting - score_candidates = txwt.copy() - score_candidates[z_pad:] = score_candidates[z_pad:] + cumscore[time_range[z_pad:]] + beats : np.ndarray [shape=(m,)] + frame numbers of estimated beat events - # Find the best predecessor beat - beat_location = numpy.argmax(score_candidates) - current_score = score_candidates[beat_location] + .. note:: + If no onset strength could be detected, beat_tracker estimates 0 BPM + and returns an empty list. - # Add the local score - cumscore[i] = current_score + localscore[i] - # Special case the first onset. Stop if the localscore is small - if first_beat and localscore[i] < 0.01 * max_localscore: - backlink[i] = -1 - else: - backlink[i] = time_range[beat_location] - first_beat = False - pass + Raises + ------ + ParameterError + if neither `y` nor `onset_envelope` are provided - # Update the time range - time_range = time_range + 1 - pass - ### Get the last beat - maxes = librosa.localmax(cumscore) - max_indices = numpy.nonzero(maxes)[0] - peak_scores = cumscore[max_indices] + See Also + -------- + librosa.onset.onset_strength - median_score = numpy.median(peak_scores) - bestendposs = numpy.nonzero(cumscore * maxes > 0.5 * median_score)[0] - # The last of these is the last beat (since score generally increases) - bestendx = numpy.max(bestendposs) + Examples + -------- + Track beats using time series input + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + + >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr) + >>> tempo + 129.19921875 + + + Print the first 20 beat frames + + >>> beats[:20] + array([ 461, 500, 540, 580, 619, 658, 698, 737, 777, + 817, 857, 896, 936, 976, 1016, 1055, 1095, 1135, + 1175, 1214]) + + + Or print them as timestamps + + >>> librosa.frames_to_time(beats[:20], sr=sr) + array([ 0.093, 0.534, 0.998, 1.463, 1.927, 2.368, 2.833, + 3.297, 3.762, 4.203, 4.667, 5.132, 5.596, 6.06 , + 6.525, 6.989, 7.454, 7.918, 8.382, 8.847]) + + + Track beats using a pre-computed onset envelope + + >>> onset_env = librosa.onset.onset_strength(y, sr=sr, + ... aggregate=np.median) + >>> tempo, beats = librosa.beat.beat_track(onset_envelope=onset_env, + ... sr=sr) + >>> tempo + 64.599609375 + >>> beats[:20] + array([ 461, 500, 540, 580, 619, 658, 698, 737, 777, + 817, 857, 896, 936, 976, 1016, 1055, 1095, 1135, + 1175, 1214]) + + + Plot the beat events against the onset strength envelope + + >>> import matplotlib.pyplot as plt + >>> hop_length = 512 + >>> plt.figure() + >>> plt.plot(librosa.util.normalize(onset_env), label='Onset strength') + >>> plt.vlines(beats, 0, 1, alpha=0.5, color='r', + ... linestyle='--', label='Beats') + >>> plt.legend(frameon=True, framealpha=0.75) + >>> # Limit the plot to a 15-second window + >>> plt.xlim([10 * sr / hop_length, 25 * sr / hop_length]) + >>> plt.xticks(np.linspace(10, 25, 5) * sr / hop_length, + ... np.linspace(10, 25, 5)) + >>> plt.xlabel('Time (s)') + >>> plt.tight_layout() + ''' + + # First, get the frame->beat strength profile if we don't already have one + if onset_envelope is None: + if y is None: + raise ParameterError('y or onset_envelope must be provided') + + onset_envelope = onset.onset_strength(y=y, + sr=sr, + hop_length=hop_length, + aggregate=np.median) + + # Do we have any onsets to grab? + if not onset_envelope.any(): + return (0, np.array([], dtype=int)) + + # Estimate BPM if one was not provided + if bpm is None: + bpm = estimate_tempo(onset_envelope, + sr=sr, + hop_length=hop_length, + start_bpm=start_bpm) + + # Then, run the tracker + beats = __beat_tracker(onset_envelope, + bpm, + float(sr) / hop_length, + tightness, + trim) + + return (bpm, beats) + + +@cache +def estimate_tempo(onset_envelope, sr=22050, hop_length=512, start_bpm=120, + std_bpm=1.0, ac_size=4.0, duration=90.0, offset=0.0): + """Estimate the tempo (beats per minute) from an onset envelope + + + Parameters + ---------- + onset_envelope : np.ndarray [shape=(n,)] + onset strength envelope + + sr : number > 0 [scalar] + sampling rate of the time series + + hop_length : int > 0 [scalar] + hop length of the time series - b = [int(bestendx)] + start_bpm : float [scalar] + initial guess of the BPM - while backlink[b[-1]] >= 0: - b.append(backlink[b[-1]]) - pass + std_bpm : float > 0 [scalar] + standard deviation of tempo distribution - b.reverse() - return numpy.array(b) + ac_size : float > 0 [scalar] + length (in seconds) of the auto-correlation window -def onset_estimate_bpm(onsets, start_bpm, sr, hop_length): + duration : float > 0 [scalar] + length of signal (in seconds) to use in estimating tempo - auto_correlation_size = 4.0 - sample_duration = 90.0 - sample_end_time = 90.0 - bpm_std = 1.0 + offset : float > 0 [scalar] + offset (in seconds) of signal sample to use in estimating tempo - fft_resolution = numpy.float(sr) / hop_length - # Chop onsets to X[(upper_limit - duration):upper_limit], or as much as will fit - maxcol = min(numpy.round(sample_end_time * fft_resolution), len(onsets)-1) - mincol = max(0, maxcol - numpy.round(sample_duration * fft_resolution)) + Returns + ------- + tempo : float [scalar] + estimated tempo (beats per minute) + + + See Also + -------- + librosa.onset.onset_strength + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> onset_env = librosa.onset.onset_strength(y, sr=sr) + >>> tempo = librosa.beat.estimate_tempo(onset_env, sr=sr) + >>> tempo + 129.19921875 + + Plot the estimated tempo against the onset autocorrelation + + >>> import matplotlib.pyplot as plt + >>> # Compute 2-second windowed autocorrelation + >>> hop_length = 512 + >>> ac = librosa.autocorrelate(onset_env, 2 * sr // hop_length) + >>> # Convert tempo estimate from bpm to frames + >>> tempo_frames = (60 * sr / hop_length) / tempo + >>> plt.plot(librosa.util.normalize(ac), + ... label='Onset autocorrelation') + >>> plt.vlines([tempo_frames], 0, 1, + ... color='r', alpha=0.75, linestyle='--', + ... label='Tempo: {:.2f} BPM'.format(tempo)) + >>> librosa.display.time_ticks(librosa.frames_to_time(np.arange(len(ac)), + ... sr=sr)) + >>> plt.xlabel('Lag') + >>> plt.legend() + >>> plt.axis('tight') + """ + + if start_bpm <= 0: + raise ParameterError('start_bpm must be strictly positive') + + fft_res = float(sr) / hop_length + + # Chop onsets to X[(upper_limit - duration):upper_limit] + # or as much as will fit + maxcol = int(min(len(onset_envelope)-1, + np.round((offset + duration) * fft_res))) + + mincol = int(max(0, maxcol - np.round(duration * fft_res))) # Use auto-correlation out of 4 seconds (empirically set??) - ac_window = int(numpy.round(auto_correlation_size * fft_resolution)) + ac_window = min(maxcol, np.round(ac_size * fft_res)) # Compute the autocorrelation - x_corr = librosa.autocorrelate(onsets[mincol:maxcol], ac_window) + x_corr = core.autocorrelate(onset_envelope[mincol:maxcol], ac_window) # re-weight the autocorrelation by log-normal prior - # FIXME: 2013-01-25 08:55:40 by Brian McFee - # this fails if ac_window > length of song + bpms = 60.0 * fft_res / (np.arange(1, ac_window+1)) - bpms = 60.0 * fft_resolution / (numpy.arange(1, ac_window+1)) - x_corr_weighting = numpy.exp(-0.5 * ((numpy.log2(bpms) - numpy.log2(start_bpm)) / bpm_std)**2) - - # Compute the weighted autocorrelation - x_corr = x_corr * x_corr_weighting + # Smooth the autocorrelation by a log-normal distribution + x_corr = x_corr * np.exp(-0.5 * ((np.log2(bpms / start_bpm)) / std_bpm)**2) # Get the local maximum of weighted correlation - x_peaks = librosa.localmax(x_corr) + x_peaks = util.localmax(x_corr) # Zero out all peaks before the first negative - x_peaks[:numpy.argmax(x_corr < 0)] = False - - # Find the largest (local) max - start_period = numpy.argmax(x_peaks * x_corr) + x_peaks[:np.argmax(x_corr < 0)] = False # Choose the best peak out of .33, .5, 2, 3 * start_period - candidate_periods = numpy.multiply(start_period, [1.0/3, 1.0/2, 1.0, 2.0, 3.0]).astype(int) - candidate_periods = candidate_periods[candidate_periods < ac_window] + candidates = np.argmax(x_peaks * x_corr) * np.asarray([1./3, 0.5, 1, 2, 3]) + + candidates = candidates[candidates < ac_window].astype(int) - best_period = numpy.argmax(x_corr[candidate_periods]) + best_period = np.argmax(x_corr[candidates]) - start_bpm = 60.0 * fft_resolution / candidate_periods[best_period] + if candidates[best_period] > 0: + return 60.0 * fft_res / candidates[best_period] return start_bpm -def onset_strength_percussive(y, sr=22050, window_length=2048, hop_length=256, mel_channels=128, S=None): - ''' - Onset strength derived from harmonic-percussive source separation - - Input: - y: time series signal - sr: sample rate of y | default: 22050 - window_length: fourier analysis window length | default: 2048 - hop_length: number of frames to hop | default: 256 - mel_channels: number of mel bins to use | default: 128 - ''' - # Step 1: compute spectrogram - if S is None: - S = librosa.melspectrogram(y, sr=sr, - window_length=window_length, - hop_length=hop_length, - mel_channels=mel_channels) - pass +@cache +def __beat_tracker(onset_envelope, bpm, fft_res, tightness, trim): + """Internal function that tracks beats in an onset strength envelope. - # Step 2: harmonic-percussive separation - (H, P) = librosa.hpss.hpss_median(S, p=6.0) - del H # We don't need the harmonic component anymore + Parameters + ---------- + onset_envelope : np.ndarray [shape=(n,)] + onset strength envelope - # Step 3: horizontal LoG filtering on P - P = scipy.ndimage.gaussian_laplace(P, [1.0, 0.0]) + bpm : float [scalar] + tempo estimate + fft_res : float [scalar] + resolution of the fft (sr / hop_length) - # Step 4: aggregate across frequency bands - O = numpy.mean(P, axis=0) + tightness: float [scalar] + how closely do we adhere to bpm? + trim : bool [scalar] + trim leading/trailing beats with weak onsets? - ### remove the DC component - O = scipy.signal.lfilter([1.0, -1.0], [1.0, -0.99], O) + Returns + ------- + beats : np.ndarray [shape=(n,)] + frame numbers of beat events + """ - # Threshold at 0 - O = numpy.maximum(0.0, O) + if bpm <= 0: + raise ParameterError('bpm must be strictly positive') - ### Normalize by the maximum onset strength - Onorm = numpy.max(O) - if Onorm == 0: - Onorm = 1.0 - pass + # convert bpm to a sample period for searching + period = round(60.0 * fft_res / bpm) - return O / Onorm + # localscore is a smoothed version of AGC'd onset envelope + localscore = __beat_local_score(onset_envelope, period) -def onset_strength(y, sr=22050, window_length=2048, hop_length=256, mel_channels=40, rising=True, htk=False, S=None): - ''' - Adapted from McVicar, adapted from Ellis, etc... - - Extract onsets - - INPUT: - y = time-series waveform (t-by-1 vector) - sr = sampling rate of the input signal | default: 22050 - window_length = number of samples per frame | default: 2048 | = 92.8ms @ 22KHz - hop_length = offset between frames | default: 256 | = 11.6ms @ 22KHz - mel_channels = number of Mel bins to use | default: 40 - rising = detect only rising edges of beats | default: True - htk = use HTK mels instead of Slaney | default: False - S = (optional) pre-computed spectrogram | default: None - - - OUTPUT: - onset_envelope - ''' + # run the DP + backlink, cumscore = __beat_track_dp(localscore, period, tightness) - gain_threshold = 80.0 + # get the position of the last beat + beats = [__last_beat(cumscore)] - # First, compute mel spectrogram - if S is None: - S = librosa.melspectrogram(y, sr=sr, - window_length=window_length, - hop_length=hop_length, - mel_channels=mel_channels, - htk=htk) - # Convert to dBs - S = librosa.logamplitude(S) + # Reconstruct the beat path from backlinks + while backlink[beats[-1]] >= 0: + beats.append(backlink[beats[-1]]) - pass + # Put the beats in ascending order + # Convert into an array of frame numbers + beats = np.array(beats[::-1], dtype=int) - ### Only look at top 80 dB - onsets = numpy.maximum(S, S.max() - gain_threshold) + # Discard spurious trailing beats + beats = __trim_beats(localscore, beats, trim) - ### Compute first difference - onsets = numpy.diff(onsets, n=1, axis=1) + return beats - ### Discard negatives (decreasing amplitude) - # falling edges could also be useful segmentation cues - # to catch falling edges, replace max(0,D) with abs(D) - if rising: - onsets = numpy.maximum(0.0, onsets) - else: - onsets = onsets**2 - pass - ### Average over mel bands - onsets = numpy.mean(onsets, axis=0) +# -- Helper functions for beat tracking +def __normalize_onsets(onsets): + '''Maps onset strength function into the range [0, 1]''' - ### remove the DC component - onsets = scipy.signal.lfilter([1.0, -1.0], [1.0, -0.99], onsets) + norm = onsets.std(ddof=1) + if norm > 0: + onsets = onsets / norm + return onsets - ### Threshold at zero - onsets = numpy.maximum(0.0, onsets) - ### Normalize by the maximum onset strength - Onorm = numpy.max(onsets) - if Onorm == 0: - Onorm = 1.0 - pass +def __beat_local_score(onset_envelope, period): + '''Construct the local score for an onset envlope and given period''' - return onsets / Onorm + window = np.exp(-0.5 * (np.arange(-period, period+1)*32.0/period)**2) + return scipy.signal.convolve(__normalize_onsets(onset_envelope), + window, + 'same') -def segment(X, k): - ''' - Perform bottom-up temporal segmentation - Input: - X: d-by-t spectrogram (t frames) - k: number of segments to produce +def __beat_track_dp(localscore, period, tightness): + """Core dynamic program for beat tracking""" - Output: - s: segment boundaries (frame numbers) - centroid: d-by-k centroids (ordered temporall) - variance: d-by-k variance (mean distortion) for each segment + backlink = np.zeros_like(localscore, dtype=int) + cumscore = np.zeros_like(localscore) - ''' + # Search range for previous beat + window = np.arange(-2 * period, -np.round(period / 2) + 1, dtype=int) - # Connect the temporal connectivity graph - G = sklearn.feature_extraction.image.grid_to_graph(n_x=X.shape[1], n_y=1, n_z=1) + # Make a score window, which begins biased toward start_bpm and skewed + if tightness <= 0: + raise ParameterError('tightness must be strictly positive') - # Instantiate the clustering object - W = sklearn.cluster.Ward(n_clusters=k, connectivity=G) + txwt = -tightness * (np.log(-window / period) ** 2) - # Fit the model - W.fit(X.T) + # Are we on the first beat? + first_beat = True + for i, score_i in enumerate(localscore): + + # Are we reaching back before time 0? + z_pad = np.maximum(0, min(- window[0], len(window))) + + # Search over all possible predecessors + candidates = txwt.copy() + candidates[z_pad:] = candidates[z_pad:] + cumscore[window[z_pad:]] + + # Find the best preceding beat + beat_location = np.argmax(candidates) - # Instantiate output objects - C = numpy.zeros( (X.shape[0], k) ) - V = numpy.zeros( (X.shape[0], k) ) - N = numpy.zeros(k, dtype=int) + # Add the local score + cumscore[i] = score_i + candidates[beat_location] - # Find the change points from the labels - d = list(1 + numpy.nonzero(numpy.diff(W.labels_))[0].astype(int)) + # Special case the first onset. Stop if the localscore is small + if first_beat and score_i < 0.01 * localscore.max(): + backlink[i] = -1 + else: + backlink[i] = window[beat_location] + first_beat = False + + # Update the time range + window = window + 1 - # tack on the last frame as a change point - d.append(X.shape[1]) + return backlink, cumscore - s = 0 - for (i, t) in enumerate(d): - N[i] = s - C[:,i] = numpy.mean(X[:,s:t], axis=1) - V[:,i] = numpy.var(X[:,s:t], axis=1) - s = t - pass - return (N, C, V) +def __last_beat(cumscore): + """Get the last beat from the cumulative score array""" + + maxes = util.localmax(cumscore) + med_score = np.median(cumscore[np.argwhere(maxes)]) + + # The last of these is the last beat (since score generally increases) + return np.argwhere((cumscore * maxes * 2 > med_score)).max() + + +def __trim_beats(localscore, beats, trim): + """Final post-processing: throw out spurious leading/trailing beats""" + + smooth_boe = scipy.signal.convolve(localscore[beats], + scipy.signal.hann(5), + 'same') + + if trim: + threshold = 0.5 * ((smooth_boe**2).mean()**0.5) + else: + threshold = 0.0 + + valid = np.argwhere(smooth_boe > threshold) + return beats[valid.min():valid.max()] diff --git a/librosa/cache.py b/librosa/cache.py new file mode 100644 index 0000000000..7bd7b83810 --- /dev/null +++ b/librosa/cache.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Function caching""" + +import os +import sys +from joblib import Memory + + +class CacheManager(Memory): + '''The librosa cache manager class extends joblib.Memory + with a __call__ attribute, so that it may act as a function. + + This allows us to override the librosa.cache module's __call__ + field, thereby allowing librosa.cache to act as a decorator function. + ''' + + def __call__(self, function): + '''Decorator function. Adds an input/output cache to + the specified function.''' + + from decorator import FunctionMaker + + def decorator_apply(dec, func): + """Decorate a function by preserving the signature even if dec + is not a signature-preserving decorator. + + This recipe is derived from + http://micheles.googlecode.com/hg/decorator/documentation.html#id14 + """ + + return FunctionMaker.create( + func, 'return decorated(%(signature)s)', + dict(decorated=dec(func)), __wrapped__=func) + + if self.cachedir is not None: + return decorator_apply(self.cache, function) + + else: + return function + +# Instantiate the cache from the environment +CACHE = CacheManager(os.environ.get('LIBROSA_CACHE_DIR', None), + mmap_mode=os.environ.get('LIBROSA_CACHE_MMAP', None), + compress=os.environ.get('LIBROSA_CACHE_COMPRESS', False), + verbose=int(os.environ.get('LIBROSA_CACHE_VERBOSE', 0))) + +# Override the module's __call__ attribute +sys.modules[__name__] = CACHE diff --git a/librosa/chroma.py b/librosa/chroma.py deleted file mode 100644 index 1295ccf7f5..0000000000 --- a/librosa/chroma.py +++ /dev/null @@ -1,119 +0,0 @@ -#!/usr/bin/env python - -import librosa -import numpy - -# FIXME: 2013-01-25 09:39:26 by Brian McFee -# this needs to be much more efficient -# framevector should be a frame array, or spectrogram, not a single frame -# or just an arbitrary-length audio sample to plug into stft -def chroma(framevector, sr, nchroma=12, A440=440.0, ctroct=5.0, octwidth=0, order=None): - ''' - Extract chroma from an audio frame - - Input: - framevector: the audio frame - sr: sampling rate - nchroma: chroma dimensionality | 12 - A440: reference frequency of A440 (Hz) | 440.0 - ctroct: center octave | 5.0 - octwidth: width of an octave | 0 - order: order of the normalizer (numpy.linalg.norm) | None, 2 - - Output: - C: normalized chroma feature - ''' - nfft = len(framevector) - F = numpy.abs(numpy.fft.fft(framevector)) - fft2chmx = chromafb(sr, nfft, nchroma, A440, ctroct, octwidth) - - # this is unnormalized chroma - unchroma = numpy.dot(fft2chmx, F[:nfft/2 + 1]) - - return unchroma / numpy.linalg.norm(unchroma, order) - -def schroma(S, sr, nchroma=12, A440=440.0, ctroct=5.0, octwidth=0, norm='inf'): - - nfft = (S.shape[0] -1 ) * 2.0 - - spec2chroma = chromafb(sr, nfft, nchroma, A440=A440, ctroct=ctroct, octwidth=octwidth) - - # Compute raw chroma - U = numpy.dot(spec2chroma, S) - - # Compute normalization factor for each frame - if norm == 'inf': - Z = numpy.max(numpy.abs(U), axis=0) - elif norm == 1: - Z = numpy.sum(numpy.abs(U), axis=0) - elif norm == 2: - Z = numpy.sum( (U**2), axis=0) ** 0.5 - else: - raise ValueError("norm must be one of: 'inf', 1, 2") - - # Tile the normalizer to match U's shape - Z[Z==0] = 1.0 - Z = numpy.tile(1.0/Z, (U.shape[0], 1)) - - return Z * U - - -def chromafb(sr, nfft, nchroma, A440=440.0, ctroct=5.0, octwidth=0): - """Create a Filterbank matrix to convert FFT to Chroma. - - Based on Dan Ellis's fft2chromamx.m - - Parameters - ---------- - sr: int - Sampling rate of the incoming signal. - nfft : int - FFT length to use. - nchroma : int - Number of chroma dimensions to return (number of bins per octave). - A440 : float - Reference frequency in Hz for A. Defaults to 440. - ctroct, octwidth : float - These parameters specify a dominance window - Gaussian - weighting centered on ctroct (in octs, re A0 = 27.5Hz) and - with a gaussian half-width of octwidth. Defaults to - halfwidth = inf i.e. flat. - """ - - wts = numpy.zeros((nchroma, nfft)) - - fftfrqbins = nchroma * librosa.hz_to_octs(numpy.arange(1, nfft, dtype='d') / nfft - * sr, A440) - - # make up a value for the 0 Hz bin = 1.5 octaves below bin 1 - # (so chroma is 50% rotated from bin 1, and bin width is broad) - fftfrqbins = numpy.concatenate(([fftfrqbins[0] - 1.5 * nchroma], fftfrqbins)) - - binwidthbins = numpy.concatenate( - (numpy.maximum(fftfrqbins[1:] - fftfrqbins[:-1], 1.0), [1])) - - D = numpy.tile(fftfrqbins, (nchroma,1)) \ - - numpy.tile(numpy.arange(0, nchroma, dtype='d')[:,numpy.newaxis], (1,nfft)) - - nchroma2 = round(nchroma / 2.0); - - # Project into range -nchroma/2 .. nchroma/2 - # add on fixed offset of 10*nchroma to ensure all values passed to - # rem are +ve - D = numpy.remainder(D + nchroma2 + 10*nchroma, nchroma) - nchroma2; - - # Gaussian bumps - 2*D to make them narrower - wts = numpy.exp(-0.5 * (2*D / numpy.tile(binwidthbins, (nchroma,1)))**2) - - # normalize each column - wts /= numpy.tile(numpy.sqrt(numpy.sum(wts**2, 0)), (nchroma,1)) - - # Maybe apply scaling for fft bins - if octwidth > 0: - wts *= numpy.tile( - numpy.exp(-0.5 * (((fftfrqbins/nchroma - ctroct)/octwidth)**2)), - (nchroma, 1)) - - # remove aliasing columns - return wts[:,:nfft/2+1] - diff --git a/librosa/core/__init__.py b/librosa/core/__init__.py new file mode 100644 index 0000000000..ec206264fb --- /dev/null +++ b/librosa/core/__init__.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Core IO and DSP +=============== + +Audio processing +---------------- +.. autosummary:: + :toctree: generated/ + + load + to_mono + resample + get_duration + autocorrelate + zero_crossings + clicks + +Spectral representations +------------------------ +.. autosummary:: + :toctree: generated/ + + stft + istft + ifgram + cqt + hybrid_cqt + pseudo_cqt + fmt + + phase_vocoder + + magphase + logamplitude + perceptual_weighting + A_weighting + +Time and frequency conversion +----------------------------- +.. autosummary:: + :toctree: generated/ + + frames_to_samples + frames_to_time + samples_to_frames + samples_to_time + time_to_frames + time_to_samples + + hz_to_note + hz_to_midi + midi_to_hz + midi_to_note + note_to_hz + note_to_midi + + hz_to_mel + hz_to_octs + mel_to_hz + octs_to_hz + + fft_frequencies + cqt_frequencies + mel_frequencies + + +Pitch and tuning +---------------- +.. autosummary:: + :toctree: generated/ + + estimate_tuning + pitch_tuning + piptrack + + +Deprecated +---------- +.. autosummary:: + :toctree: generated/ + + ifptrack + +""" + +from .time_frequency import * # pylint: disable=wildcard-import +from .audio import * # pylint: disable=wildcard-import +from .spectrum import * # pylint: disable=wildcard-import +from .pitch import * # pylint: disable=wildcard-import +from .constantq import * # pylint: disable=wildcard-import + +__all__ = [_ for _ in dir() if not _.startswith('_')] + diff --git a/librosa/core/audio.py b/librosa/core/audio.py new file mode 100644 index 0000000000..0c5087b8f3 --- /dev/null +++ b/librosa/core/audio.py @@ -0,0 +1,680 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Core IO, DSP and utility functions.""" + +import os +import warnings +import six + +import audioread +import numpy as np +import scipy.signal +import scipy.fftpack as fft +import resampy + +from .time_frequency import frames_to_samples, time_to_samples +from .. import cache +from .. import util +from ..util.exceptions import ParameterError + +__all__ = ['load', 'to_mono', 'resample', 'get_duration', + 'autocorrelate', 'zero_crossings', 'clicks', + # Deprecated functions + 'peak_pick', 'localmax'] + +# Resampling bandwidths as percentage of Nyquist +# http://resampy.readthedocs.org/en/latest/api.html#module-resampy.filters +BW_BEST = 0.9476 +BW_FASTEST = 0.85 + +# Do we have scikits.samplerate? +try: + # Pylint won't handle dynamic imports, so we suppress this warning + import scikits.samplerate as samplerate # pylint: disable=import-error + _HAS_SAMPLERATE = True +except ImportError: + _HAS_SAMPLERATE = False + + +# -- CORE ROUTINES --# +# Load should never be cached, since we cannot verify that the contents of +# 'path' are unchanged across calls. +def load(path, sr=22050, mono=True, offset=0.0, duration=None, + dtype=np.float32): + """Load an audio file as a floating point time series. + + Parameters + ---------- + path : string + path to the input file. + + Any format supported by `audioread` will work. + + sr : number > 0 [scalar] + target sampling rate + + 'None' uses the native sampling rate + + mono : bool + convert signal to mono + + offset : float + start reading after this time (in seconds) + + duration : float + only load up to this much audio (in seconds) + + dtype : numeric type + data type of `y` + + + Returns + ------- + y : np.ndarray [shape=(n,) or (2, n)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + + Examples + -------- + >>> # Load a wav file + >>> filename = librosa.util.example_audio_file() + >>> y, sr = librosa.load(filename) + >>> y + array([ -4.756e-06, -6.020e-06, ..., -1.040e-06, 0.000e+00], dtype=float32) + >>> sr + 22050 + + >>> # Load a wav file and resample to 11 KHz + >>> filename = librosa.util.example_audio_file() + >>> y, sr = librosa.load(filename, sr=11025) + >>> y + array([ -2.077e-06, -2.928e-06, ..., -4.395e-06, 0.000e+00], dtype=float32) + >>> sr + 11025 + + >>> # Load 5 seconds of a wav file, starting 15 seconds in + >>> filename = librosa.util.example_audio_file() + >>> y, sr = librosa.load(filename, offset=15.0, duration=5.0) + >>> y + array([ 0.069, 0.1 , ..., -0.101, 0. ], dtype=float32) + >>> sr + 22050 + + """ + + y = [] + with audioread.audio_open(os.path.realpath(path)) as input_file: + sr_native = input_file.samplerate + n_channels = input_file.channels + + s_start = int(np.round(sr_native * offset)) * n_channels + + if duration is None: + s_end = np.inf + else: + s_end = s_start + (int(np.round(sr_native * duration)) + * n_channels) + + n = 0 + + for frame in input_file: + frame = util.buf_to_float(frame, dtype=dtype) + n_prev = n + n = n + len(frame) + + if n < s_start: + # offset is after the current frame + # keep reading + continue + + if s_end < n_prev: + # we're off the end. stop reading + break + + if s_end < n: + # the end is in this frame. crop. + frame = frame[:s_end - n_prev] + + if n_prev <= s_start <= n: + # beginning is in this frame + frame = frame[(s_start - n_prev):] + + # tack on the current frame + y.append(frame) + + if y: + y = np.concatenate(y) + + if n_channels > 1: + y = y.reshape((-1, 2)).T + if mono: + y = to_mono(y) + + if sr is not None: + y = resample(y, sr_native, sr) + + else: + sr = sr_native + + # Final cleanup for dtype and contiguity + y = np.ascontiguousarray(y, dtype=dtype) + + return (y, sr) + + +@cache +def to_mono(y): + '''Force an audio signal down to mono. + + Parameters + ---------- + y : np.ndarray [shape=(2,n) or shape=(n,)] + audio time series, either stereo or mono + + Returns + ------- + y_mono : np.ndarray [shape=(n,)] + `y` as a monophonic time-series + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file(), mono=False) + >>> y.shape + (2, 1355168) + >>> y_mono = librosa.to_mono(y) + >>> y_mono.shape + (1355168,) + + ''' + + # Validate the buffer. Stereo is ok here. + util.valid_audio(y, mono=False) + + if y.ndim > 1: + y = np.mean(y, axis=0) + + return y + + +@cache +def resample(y, orig_sr, target_sr, res_type='kaiser_best', fix=True, scale=False, **kwargs): + """Resample a time series from orig_sr to target_sr + + Parameters + ---------- + y : np.ndarray [shape=(n,) or shape=(2, n)] + audio time series. Can be mono or stereo. + + orig_sr : number > 0 [scalar] + original sampling rate of `y` + + target_sr : number > 0 [scalar] + target sampling rate + + res_type : str + resample type (see note) + + .. note:: + By default, this uses `resampy`'s high-quality mode ('kaiser_best'). + If `res_type` is not recognized by `resampy.resample`, it then + falls back on `scikits.samplerate` (if it is installed) + + If both of those fail, it will fall back on `scipy.signal.resample`. + + To force use of `scipy.signal.resample`, set `res_type='scipy'`. + + fix : bool + adjust the length of the resampled signal to be of size exactly + `ceil(target_sr * len(y) / orig_sr)` + + scale : bool + Scale the resampled signal so that `y` and `y_hat` have approximately + equal total energy. + + kwargs : additional keyword arguments + If `fix==True`, additional keyword arguments to pass to + `librosa.util.fix_length`. + + Returns + ------- + y_hat : np.ndarray [shape=(n * target_sr / orig_sr,)] + `y` resampled from `orig_sr` to `target_sr` + + + See Also + -------- + librosa.util.fix_length + scipy.signal.resample + + Examples + -------- + Downsample from 22 KHz to 8 KHz + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), sr=22050) + >>> y_8k = librosa.resample(y, sr, 8000) + >>> y.shape, y_8k.shape + ((1355168,), (491671,)) + + """ + + # First, validate the audio buffer + util.valid_audio(y, mono=False) + + if orig_sr == target_sr: + return y + + ratio = float(target_sr) / orig_sr + + n_samples = int(np.ceil(y.shape[-1] * ratio)) + + try: + y_hat = resampy.resample(y, orig_sr, target_sr, filter=res_type, axis=-1) + except NotImplementedError: + if _HAS_SAMPLERATE and (res_type != 'scipy'): + warnings.warn('scikits.samplerate resampling is deprecated as ' + 'of librosa version 0.4.3.\n\tSupport will be ' + 'removed in librosa version 0.5.', + category=DeprecationWarning) + y_hat = samplerate.resample(y.T, ratio, res_type).T + else: + y_hat = scipy.signal.resample(y, n_samples, axis=-1) + + if fix: + y_hat = util.fix_length(y_hat, n_samples, **kwargs) + + if scale: + y_hat /= np.sqrt(ratio) + + return np.ascontiguousarray(y_hat, dtype=y.dtype) + + +def get_duration(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + center=True): + """Compute the duration (in seconds) of an audio time series or STFT matrix. + + Examples + -------- + >>> # Load the example audio file + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.get_duration(y=y, sr=sr) + 61.44 + + >>> # Or compute duration from an STFT matrix + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = librosa.stft(y) + >>> librosa.get_duration(S=S, sr=sr) + 61.44 + + >>> # Or a non-centered STFT matrix + >>> S_left = librosa.stft(y, center=False) + >>> librosa.get_duration(S=S_left, sr=sr) + 61.3471201814059 + + Parameters + ---------- + y : np.ndarray [shape=(n,), (2, n)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + STFT matrix, or any STFT-derived matrix (e.g., chromagram + or mel spectrogram). + + n_fft : int > 0 [scalar] + FFT window size for `S` + + hop_length : int > 0 [ scalar] + number of audio samples between columns of `S` + + center : boolean + - If `True`, `S[:, t]` is centered at `y[t * hop_length]` + - If `False`, then `S[:, t]` begins at `y[t * hop_length]` + + Returns + ------- + d : float >= 0 + Duration (in seconds) of the input time series or spectrogram. + """ + + if y is None: + assert S is not None + + n_frames = S.shape[1] + n_samples = n_fft + hop_length * (n_frames - 1) + + # If centered, we lose half a window from each end of S + if center: + n_samples = n_samples - 2 * int(n_fft / 2) + + else: + # Validate the audio buffer. Stereo is okay here. + util.valid_audio(y, mono=False) + if y.ndim == 1: + n_samples = len(y) + else: + n_samples = y.shape[-1] + + return float(n_samples) / sr + + +@cache +def autocorrelate(y, max_size=None, axis=-1): + """Bounded auto-correlation + + Parameters + ---------- + y : np.ndarray + array to autocorrelate + + max_size : int > 0 or None + maximum correlation lag. + If unspecified, defaults to `y.shape[axis]` (unbounded) + + axis : int + The axis along which to autocorrelate. + By default, the last axis (-1) is taken. + + Returns + ------- + z : np.ndarray + truncated autocorrelation `y*y` along the specified axis. + If `max_size` is specified, then `z.shape[axis]` is bounded + to `max_size`. + + Examples + -------- + Compute full autocorrelation of y + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.autocorrelate(y) + array([ 1.584e+04, 1.580e+04, ..., -1.154e-10, -2.725e-13]) + + + Compute onset strength auto-correlation up to 4 seconds + + >>> import matplotlib.pyplot as plt + >>> odf = librosa.onset.onset_strength(y=y, sr=sr, hop_length=512) + >>> ac = librosa.autocorrelate(odf, max_size=4* sr / 512) + >>> plt.plot(ac) + >>> plt.title('Auto-correlation') + >>> plt.xlabel('Lag (frames)') + + """ + + if max_size is None: + max_size = y.shape[axis] + + max_size = int(min(max_size, y.shape[axis])) + + # Compute the power spectrum along the chosen axis + # Pad out the signal to support full-length auto-correlation. + powspec = np.abs(fft.fft(y, n=2 * y.shape[axis] + 1, axis=axis))**2 + + # Convert back to time domain + autocorr = fft.ifft(powspec, axis=axis, overwrite_x=True) + + # Slice down to max_size + subslice = [slice(None)] * autocorr.ndim + subslice[axis] = slice(max_size) + + autocorr = autocorr[subslice] + + if not np.iscomplexobj(y): + autocorr = autocorr.real + + return autocorr + + +@cache +def zero_crossings(y, threshold=1e-10, ref_magnitude=None, pad=True, + zero_pos=True, axis=-1): + '''Find the zero-crossings of a signal `y`: indices `i` such that + `sign(y[i]) != sign(y[j])`. + + If `y` is multi-dimensional, then zero-crossings are computed along + the specified `axis`. + + Examples + -------- + >>> # Generate a time-series + >>> y = np.sin(np.linspace(0, 4 * 2 * np.pi, 20)) + >>> y + array([ 0.000e+00, 9.694e-01, 4.759e-01, -7.357e-01, + -8.372e-01, 3.247e-01, 9.966e-01, 1.646e-01, + -9.158e-01, -6.142e-01, 6.142e-01, 9.158e-01, + -1.646e-01, -9.966e-01, -3.247e-01, 8.372e-01, + 7.357e-01, -4.759e-01, -9.694e-01, -9.797e-16]) + >>> # Compute zero-crossings + >>> z = librosa.zero_crossings(y) + >>> z + array([ True, False, False, True, False, True, False, False, + True, False, True, False, True, False, False, True, + False, True, False, True], dtype=bool) + >>> # Stack y against the zero-crossing indicator + >>> np.vstack([y, z]).T + array([[ 0.000e+00, 1.000e+00], + [ 9.694e-01, 0.000e+00], + [ 4.759e-01, 0.000e+00], + [ -7.357e-01, 1.000e+00], + [ -8.372e-01, 0.000e+00], + [ 3.247e-01, 1.000e+00], + [ 9.966e-01, 0.000e+00], + [ 1.646e-01, 0.000e+00], + [ -9.158e-01, 1.000e+00], + [ -6.142e-01, 0.000e+00], + [ 6.142e-01, 1.000e+00], + [ 9.158e-01, 0.000e+00], + [ -1.646e-01, 1.000e+00], + [ -9.966e-01, 0.000e+00], + [ -3.247e-01, 0.000e+00], + [ 8.372e-01, 1.000e+00], + [ 7.357e-01, 0.000e+00], + [ -4.759e-01, 1.000e+00], + [ -9.694e-01, 0.000e+00], + [ -9.797e-16, 1.000e+00]]) + >>> # Find the indices of zero-crossings + >>> np.nonzero(z) + (array([ 0, 3, 5, 8, 10, 12, 15, 17, 19]),) + + + Parameters + ---------- + y : np.ndarray + The input array + + threshold : float > 0 or None + If specified, values where `-threshold <= y <= threshold` are + clipped to 0. + + ref_magnitude : float > 0 or callable + If numeric, the threshold is scaled relative to `ref_magnitude`. + + If callable, the threshold is scaled relative to + `ref_magnitude(np.abs(y))`. + + pad : boolean + If `True`, then `y[0]` is considered a valid zero-crossing. + + zero_pos : boolean + If `True` then the value 0 is interpreted as having positive sign. + + If `False`, then 0, -1, and +1 all have distinct signs. + + axis : int + Axis along which to compute zero-crossings. + + Returns + ------- + zero_crossings : np.ndarray [shape=y.shape, dtype=boolean] + Indicator array of zero-crossings in `y` along the selected axis. + ''' + + # Clip within the threshold + if threshold is None: + threshold = 0.0 + + if six.callable(ref_magnitude): + threshold = threshold * ref_magnitude(np.abs(y)) + + elif ref_magnitude is not None: + threshold = threshold * ref_magnitude + + if threshold > 0: + y = y.copy() + y[np.abs(y) <= threshold] = 0 + + # Extract the sign bit + if zero_pos: + y_sign = np.signbit(y) + else: + y_sign = np.sign(y) + + # Find the change-points by slicing + slice_pre = [slice(None)] * y.ndim + slice_pre[axis] = slice(1, None) + + slice_post = [slice(None)] * y.ndim + slice_post[axis] = slice(-1) + + # Since we've offset the input by one, pad back onto the front + padding = [(0, 0)] * y.ndim + padding[axis] = (1, 0) + + return np.pad((y_sign[slice_post] != y_sign[slice_pre]), + padding, + mode='constant', + constant_values=pad) + + +@cache +def clicks(times=None, frames=None, sr=22050, hop_length=512, + click_freq=1000.0, click_duration=0.1, click=None, length=None): + """Returns a signal with the signal `click` placed at each specified time + + Parameters + ---------- + times : np.ndarray or None + times to place clicks, in seconds + + frames : np.ndarray or None + frame indices to place clicks + + sr : number > 0 + desired sampling rate of the output signal + + hop_length : int > 0 + if positions are specified by `frames`, the number of samples between frames. + + click_freq : float > 0 + frequency (in Hz) of the default click signal. Default is 1KHz. + + click_duration : float > 0 + duration (in seconds) of the default click signal. Default is 100ms. + + click : np.ndarray or None + optional click signal sample to use instead of the default blip. + + length : int > 0 + desired number of samples in the output signal + + + Returns + ------- + click_signal : np.ndarray + Synthesized click signal + + + Raises + ------ + ParameterError + - If neither `times` nor `frames` are provided. + - If any of `click_freq`, `click_duration`, or `length` are out of range. + + + Examples + -------- + >>> # Sonify detected beat events + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr) + >>> y_beats = librosa.clicks(frames=beats, sr=sr) + + >>> # Or generate a signal of the same length as y + >>> y_beats = librosa.clicks(frames=beats, sr=sr, length=len(y)) + + >>> # Or use timing instead of frame indices + >>> times = librosa.frames_to_time(beats, sr=sr) + >>> y_beat_times = librosa.clicks(times=times, sr=sr) + + >>> # Or with a click frequency of 880Hz and a 500ms sample + >>> y_beat_times880 = librosa.clicks(times=times, sr=sr, + ... click_freq=880, click_duration=0.5) + """ + + # Compute sample positions from time or frames + if times is None: + if frames is None: + raise ParameterError('either "times" or "frames" must be provided') + + positions = frames_to_samples(frames, hop_length=hop_length) + else: + # Convert times to positions + positions = time_to_samples(times, sr=sr) + + if click is not None: + # Check that we have a well-formed audio buffer + util.valid_audio(click, mono=True) + + else: + # Create default click signal + if click_duration <= 0: + raise ParameterError('click_duration must be strictly positive') + + if click_freq <= 0: + raise ParameterError('click_freq must be strictly positive') + + angular_freq = 2 * np.pi * click_freq / float(sr) + + click = np.logspace(0, -10, + num=int(np.round(sr * click_duration)), + base=2.0) + + click *= np.sin(angular_freq * np.arange(len(click))) + + # Set default length + if length is None: + length = positions.max() + click.shape[0] + else: + if length < 1: + raise ParameterError('length must be a positive integer') + + # Filter out any positions past the length boundary + positions = positions[positions < length] + + # Pre-allocate click signal + click_signal = np.zeros(length, dtype=np.float32) + + # Place clicks + for start in positions: + # Compute the end-point of this click + end = start + click.shape[0] + + if end >= length: + click_signal[start:] += click[:length - start] + else: + # Normally, just add a click here + click_signal[start:end] += click + + return click_signal + + +# Moved/deprecated functions +peak_pick = util.decorators.moved('librosa.core.peak_pick', + '0.4', '0.5')(util.peak_pick) + +localmax = util.decorators.moved('librosa.core.localmax', + '0.4', '0.5')(util.localmax) diff --git a/librosa/core/constantq.py b/librosa/core/constantq.py new file mode 100644 index 0000000000..bc47256df0 --- /dev/null +++ b/librosa/core/constantq.py @@ -0,0 +1,619 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +'''Pitch-tracking and tuning estimation''' +from __future__ import division + +import numpy as np +import scipy.fftpack as fft +from warnings import warn + +from . import audio +from .time_frequency import cqt_frequencies, note_to_hz +from .spectrum import stft +from .pitch import estimate_tuning +from .. import cache +from .. import filters +from .. import util +from ..util.exceptions import ParameterError + +__all__ = ['cqt', 'hybrid_cqt', 'pseudo_cqt'] + + +@cache +def cqt(y, sr=22050, hop_length=512, fmin=None, n_bins=84, + bins_per_octave=12, tuning=None, filter_scale=1, + aggregate=None, norm=1, sparsity=0.01, real=True, + resolution=util.Deprecated()): + '''Compute the constant-Q transform of an audio signal. + + This implementation is based on the recursive sub-sampling method + described by [1]_. + + .. [1] Schoerkhuber, Christian, and Anssi Klapuri. + "Constant-Q transform toolbox for music processing." + 7th Sound and Music Computing Conference, Barcelona, Spain. 2010. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + hop_length : int > 0 [scalar] + number of samples between successive CQT columns. + + fmin : float > 0 [scalar] + Minimum frequency. Defaults to C1 ~= 32.70 Hz + + n_bins : int > 0 [scalar] + Number of frequency bins, starting at `fmin` + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : None or float in `[-0.5, 0.5)` + Tuning offset in fractions of a bin (cents). + + If `None`, tuning will be automatically estimated. + + filter_scale : float > 0 + Filter scale factor. Small values (<1) use shorter windows + for improved time resolution. + + aggregate : None or function + Aggregation function for time-oversampling energy aggregation. + By default, `np.mean`. See `librosa.util.sync`. + + norm : {inf, -inf, 0, float > 0} + Type of norm to use for basis function normalization. + See `librosa.util.normalize`. + + sparsity : float in [0, 1) + Sparsify the CQT basis by discarding up to `sparsity` + fraction of the energy in each basis. + + Set `sparsity=0` to disable sparsification. + + real : bool + If true, return only the magnitude of the CQT. + + resolution : float + .. warning:: This parameter name was in librosa 0.4.2 + Use the `filter_scale` parameter instead. + The `resolution` parameter will be removed in librosa 0.5.0. + + + Returns + ------- + CQT : np.ndarray [shape=(n_bins, t), dtype=np.complex or np.float] + Constant-Q value each frequency at each time. + + Raises + ------ + ParameterError + If `hop_length` is not an integer multiple of + `2**(n_bins / bins_per_octave)` + + See Also + -------- + librosa.core.resample + librosa.util.sync + librosa.util.normalize + + Examples + -------- + Generate and plot a constant-Q power spectrum + + >>> import matplotlib.pyplot as plt + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> C = librosa.cqt(y, sr=sr) + >>> librosa.display.specshow(librosa.logamplitude(C**2, ref_power=np.max), + ... sr=sr, x_axis='time', y_axis='cqt_note') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Constant-Q power spectrum') + >>> plt.tight_layout() + + + Limit the frequency range + + >>> C = librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('C2'), + ... n_bins=60) + >>> C + array([[ 8.827e-04, 9.293e-04, ..., 3.133e-07, 2.942e-07], + [ 1.076e-03, 1.068e-03, ..., 1.153e-06, 1.148e-06], + ..., + [ 1.042e-07, 4.087e-07, ..., 1.612e-07, 1.928e-07], + [ 2.363e-07, 5.329e-07, ..., 1.294e-07, 1.611e-07]]) + + + Using a higher frequency resolution + + >>> C = librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('C2'), + ... n_bins=60 * 2, bins_per_octave=12 * 2) + >>> C + array([[ 1.536e-05, 5.848e-05, ..., 3.241e-07, 2.453e-07], + [ 1.856e-03, 1.854e-03, ..., 2.397e-08, 3.549e-08], + ..., + [ 2.034e-07, 4.245e-07, ..., 6.213e-08, 1.463e-07], + [ 4.896e-08, 5.407e-07, ..., 9.176e-08, 1.051e-07]]) + ''' + + filter_scale = util.rename_kw('resolution', resolution, + 'filter_scale', filter_scale, + '0.4.2', '0.5.0') + + if real: + warn('Real-valued CQT (real=True) is deprecated in 0.4.2. ' + 'Complex-valued CQT will become the default in 0.5.0. ' + 'Consider using np.abs(librosa.cqt(..., real=False)) ' + 'instead of real=True to maintain forward compatibility.', + DeprecationWarning) + + # How many octaves are we dealing with? + n_octaves = int(np.ceil(float(n_bins) / bins_per_octave)) + + if fmin is None: + # C1 by default + fmin = note_to_hz('C1') + + if tuning is None: + tuning = estimate_tuning(y=y, sr=sr) + + # First thing, get the freqs of the top octave + freqs = cqt_frequencies(n_bins, fmin, + bins_per_octave=bins_per_octave)[-bins_per_octave:] + + fmin_t = np.min(freqs) + fmax_t = np.max(freqs) + + # Determine required resampling quality + Q = float(filter_scale) / (2.0**(1. / bins_per_octave) - 1) + + filter_cutoff = fmax_t * (1 + filters.window_bandwidth('hann') / Q) + + nyquist = sr / 2.0 + + if filter_cutoff < audio.BW_FASTEST * nyquist: + res_type = 'kaiser_fast' + elif filter_cutoff < audio.BW_BEST * nyquist: + res_type = 'kaiser_best' + else: + res_type = 'kaiser_best' + + cqt_resp = [] + + y, sr, hop_length = __early_downsample(y, sr, hop_length, + res_type, n_octaves, + nyquist, filter_cutoff) + + n_filters = min(bins_per_octave, n_bins) + + if res_type != 'kaiser_fast': + + # Do two octaves before resampling to allow for usage of sinc_fastest + fft_basis, n_fft, filter_lengths = __fft_filters(sr, fmin_t, + n_filters, + bins_per_octave, + tuning, + filter_scale, + norm, + sparsity) + min_filter_length = np.min(filter_lengths) + + # Compute a dynamic hop based on n_fft + my_cqt = __variable_hop_response(y, n_fft, + hop_length, + min_filter_length, + fft_basis, + aggregate) + + # Convolve + cqt_resp.append(my_cqt) + + fmin_t /= 2 + fmax_t /= 2 + n_octaves -= 1 + + filter_cutoff = fmax_t * (1 + filters.window_bandwidth('hann') / Q) + assert filter_cutoff < audio.BW_FASTEST*nyquist + + res_type = 'kaiser_fast' + + # Make sure our hop is long enough to support the bottom octave + num_twos = __num_two_factors(hop_length) + if num_twos < n_octaves - 1: + raise ParameterError('hop_length must be a positive integer ' + 'multiple of 2^{0:d} for {1:d}-octave CQT' + .format(n_octaves - 1, n_octaves)) + + # Now do the recursive bit + fft_basis, n_fft, filter_lengths = __fft_filters(sr, fmin_t, + n_filters, + bins_per_octave, + tuning, + filter_scale, + norm, + sparsity) + + min_filter_length = np.min(filter_lengths) + + my_y, my_sr, my_hop = y, sr, hop_length + + # Iterate down the octaves + for i in range(n_octaves): + + # Resample (except first time) + if i > 0: + # The additional scaling of sqrt(2) here is to implicitly rescale the filters + my_y = np.sqrt(2) * audio.resample(my_y, my_sr, my_sr/2.0, + res_type=res_type, + scale=True) + my_sr /= 2.0 + assert my_hop % 2 == 0 + my_hop //= 2 + + # Compute a dynamic hop based on n_fft + my_cqt = __variable_hop_response(my_y, n_fft, + my_hop, + min_filter_length, + fft_basis, + aggregate) + + # Convolve + cqt_resp.append(my_cqt) + + return __trim_stack(cqt_resp, n_bins, real) + + +@cache +def hybrid_cqt(y, sr=22050, hop_length=512, fmin=None, n_bins=84, + bins_per_octave=12, tuning=None, filter_scale=1, + norm=1, sparsity=0.01, + resolution=util.Deprecated()): + '''Compute the hybrid constant-Q transform of an audio signal. + + Here, the hybrid CQT uses the pseudo CQT for higher frequencies where + the hop_length is longer than half the filter length and the full CQT + for lower frequencies. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + hop_length : int > 0 [scalar] + number of samples between successive CQT columns. + + fmin : float > 0 [scalar] + Minimum frequency. Defaults to C1 ~= 32.70 Hz + + n_bins : int > 0 [scalar] + Number of frequency bins, starting at `fmin` + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : None or float in `[-0.5, 0.5)` + Tuning offset in fractions of a bin (cents). + + If `None`, tuning will be automatically estimated. + + filter_scale : float > 0 + Filter filter_scale factor. Larger values use longer windows. + + sparsity : float in [0, 1) + Sparsify the CQT basis by discarding up to `sparsity` + fraction of the energy in each basis. + + Set `sparsity=0` to disable sparsification. + + resolution : float + .. warning:: This parameter name was in librosa 0.4.2 + Use the `filter_scale` parameter instead. + The `resolution` parameter will be removed in librosa 0.5.0. + + + Returns + ------- + CQT : np.ndarray [shape=(n_bins, t), dtype=np.float] + Constant-Q energy for each frequency at each time. + + Raises + ------ + ParameterError + If `hop_length` is not an integer multiple of + `2**(n_bins / bins_per_octave)` + + See Also + -------- + cqt + pseudo_cqt + ''' + + filter_scale = util.rename_kw('resolution', resolution, + 'filter_scale', filter_scale, + '0.4.2', '0.5.0') + + if fmin is None: + # C1 by default + fmin = note_to_hz('C1') + + if tuning is None: + tuning = estimate_tuning(y=y, sr=sr) + + # Get all CQT frequencies + freqs = cqt_frequencies(n_bins, fmin, + bins_per_octave=bins_per_octave, + tuning=tuning) + + # Compute the length of each constant-Q basis function + lengths = filters.constant_q_lengths(sr, fmin, + n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=filter_scale) + + # Determine which filters to use with Pseudo CQT + pseudo_filters = lengths < 2*hop_length + n_bins_pseudo = int(np.sum(pseudo_filters)) + + cqt_resp = [] + + if n_bins_pseudo > 0: + fmin_pseudo = np.min(freqs[pseudo_filters]) + my_pseudo_cqt = pseudo_cqt(y, sr, + hop_length=hop_length, + fmin=fmin_pseudo, + n_bins=n_bins_pseudo, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=filter_scale, + norm=norm, + sparsity=sparsity) + cqt_resp.append(my_pseudo_cqt) + + n_bins_full = int(np.sum(~pseudo_filters)) + + if n_bins_full > 0: + + fmin_full = np.min(freqs[~pseudo_filters]) + + my_cqt = np.abs(cqt(y, sr, + hop_length=hop_length, + fmin=fmin_full, + n_bins=n_bins_full, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=filter_scale, + norm=norm, + sparsity=sparsity, + real=False)) + + cqt_resp.append(my_cqt) + + return __trim_stack(cqt_resp, n_bins, True) + + +@cache +def pseudo_cqt(y, sr=22050, hop_length=512, fmin=None, n_bins=84, + bins_per_octave=12, tuning=None, filter_scale=1, + norm=1, sparsity=0.01, + resolution=util.Deprecated()): + '''Compute the pseudo constant-Q transform of an audio signal. + + This uses a single fft size that is the smallest power of 2 that is greater + than or equal to the max of: + + 1. The longest CQT filter + 2. 2x the hop_length + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + hop_length : int > 0 [scalar] + number of samples between successive CQT columns. + + fmin : float > 0 [scalar] + Minimum frequency. Defaults to C1 ~= 32.70 Hz + + n_bins : int > 0 [scalar] + Number of frequency bins, starting at `fmin` + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : None or float in `[-0.5, 0.5)` + Tuning offset in fractions of a bin (cents). + + If `None`, tuning will be automatically estimated. + + filter_scale : float > 0 + Filter filter_scale factor. Larger values use longer windows. + + sparsity : float in [0, 1) + Sparsify the CQT basis by discarding up to `sparsity` + fraction of the energy in each basis. + + Set `sparsity=0` to disable sparsification. + + resolution : float + .. warning:: This parameter name was in librosa 0.4.2 + Use the `filter_scale` parameter instead. + The `resolution` parameter will be removed in librosa 0.5.0. + + + Returns + ------- + CQT : np.ndarray [shape=(n_bins, t), dtype=np.float] + Pseudo Constant-Q energy for each frequency at each time. + + Raises + ------ + ParameterError + If `hop_length` is not an integer multiple of + `2**(n_bins / bins_per_octave)` + + ''' + + filter_scale = util.rename_kw('resolution', resolution, + 'filter_scale', filter_scale, + '0.4.2', '0.5.0') + + if fmin is None: + # C1 by default + fmin = note_to_hz('C1') + + if tuning is None: + tuning = estimate_tuning(y=y, sr=sr) + + fft_basis, n_fft, _ = __fft_filters(sr, + fmin, + n_bins, + bins_per_octave, + tuning, + filter_scale, + norm, + sparsity, + hop_length=hop_length) + + fft_basis = np.abs(fft_basis) + + # Compute the magnitude STFT with Hann window + D = np.abs(stft(y, n_fft=n_fft, hop_length=hop_length)) + + # Project onto the pseudo-cqt basis + return fft_basis.dot(D) + + +def __fft_filters(sr, fmin, n_bins, bins_per_octave, tuning, + filter_scale, norm, sparsity, hop_length=None): + '''Generate the frequency domain constant-Q filter basis.''' + + basis, lengths = filters.constant_q(sr, + fmin=fmin, + n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=filter_scale, + norm=norm, + pad_fft=True) + + # Filters are padded up to the nearest integral power of 2 + n_fft = basis.shape[1] + + if hop_length is not None and n_fft < 2 * hop_length: + n_fft = int(2.0 ** (np.ceil(np.log2(2 * hop_length)))) + + # normalize by inverse length to compensate for phase invariance + basis *= lengths.reshape((-1, 1)) / n_fft + + # FFT and retain only the non-negative frequencies + fft_basis = fft.fft(basis, n=n_fft, axis=1)[:, :(n_fft // 2)+1] + + # normalize as in Parseval's relation, and sparsify the basis + fft_basis = util.sparsify_rows(fft_basis / n_fft, quantile=sparsity) + + return fft_basis, n_fft, lengths + + +def __trim_stack(cqt_resp, n_bins, real): + '''Helper function to trim and stack a collection of CQT responses''' + + # cleanup any framing errors at the boundaries + max_col = min([x.shape[1] for x in cqt_resp]) + + cqt_resp = np.vstack([x[:, :max_col] for x in cqt_resp][::-1]) + + # Finally, clip out any bottom frequencies that we don't really want + # Transpose magic here to ensure column-contiguity + + C = np.ascontiguousarray(cqt_resp[-n_bins:].T).T + if real: + C = np.abs(C) + return C + + +def __variable_hop_response(y, n_fft, hop_length, min_filter_length, + fft_basis, aggregate): + '''Compute the filter response with a target STFT hop. + If the hop is too large (more than half the frame length), + then over-sample at a smaller hop, and aggregate the results + to the desired resolution. + ''' + + # If target_hop <= n_fft / 2: + # my_hop = target_hop + # else: + # my_hop = target_hop * 2**(-k) + + zoom_factor = np.ceil(np.log2(hop_length) - np.log2(min_filter_length)) + + zoom_factor = 2**int(np.maximum(0, 1 + zoom_factor)) + + # Compute the STFT matrix + D = stft(y, n_fft=n_fft, hop_length=int(hop_length / zoom_factor), + window=np.ones) + + # And filter response energy + my_cqt = fft_basis.dot(D) + + if zoom_factor > 1: + # We need to aggregate. Generate the boundary frames + bounds = np.arange(0, my_cqt.shape[1], zoom_factor, dtype=int) + my_cqt = util.sync(my_cqt, bounds, aggregate=aggregate) + + return my_cqt + + +def __early_downsample(y, sr, hop_length, res_type, n_octaves, + nyquist, filter_cutoff): + '''Perform early downsampling on an audio signal, if it applies.''' + + if res_type != 'kaiser_fast': + return y, sr, hop_length + + downsample_count1 = int(np.ceil(np.log2(audio.BW_FASTEST * nyquist / + filter_cutoff)) - 1) + num_twos = __num_two_factors(hop_length) + downsample_count2 = max(0, num_twos - n_octaves + 1) + downsample_count = min(downsample_count1, downsample_count2) + + if downsample_count > 0: + downsample_factor = 2.0**(downsample_count) + + assert hop_length % downsample_factor == 0 + hop_length //= downsample_factor + + # The additional scaling of sqrt(downsample_factor) here is to implicitly + # rescale the filters + y = np.sqrt(downsample_factor) * audio.resample(y, sr, sr / downsample_factor, + res_type=res_type, scale=True) + + sr /= downsample_factor + + return y, sr, hop_length + + +def __num_two_factors(x): + """Return how many times integer x can be evenly divided by 2. + + Returns 0 for non-positive integers. + """ + if x <= 0: + return 0 + num_twos = 0 + while x % 2 == 0: + num_twos += 1 + x //= 2 + + return num_twos diff --git a/librosa/core/pitch.py b/librosa/core/pitch.py new file mode 100644 index 0000000000..2bd69b7a32 --- /dev/null +++ b/librosa/core/pitch.py @@ -0,0 +1,445 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +'''Pitch-tracking and tuning estimation''' + +import numpy as np +import warnings + +from .spectrum import ifgram, _spectrogram +from . import time_frequency +from .. import cache +from .. import util + +__all__ = ['estimate_tuning', 'pitch_tuning', 'piptrack', + # Deprecated functions + 'ifptrack'] + + +def estimate_tuning(y=None, sr=22050, S=None, n_fft=2048, + resolution=0.01, bins_per_octave=12, **kwargs): + '''Estimate the tuning of an audio time series or spectrogram input. + + Parameters + ---------- + y: np.ndarray [shape=(n,)] or None + audio signal + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S: np.ndarray [shape=(d, t)] or None + magnitude or power spectrogram + + n_fft : int > 0 [scalar] or None + number of FFT bins to use, if `y` is provided. + + resolution : float in `(0, 1)` + Resolution of the tuning as a fraction of a bin. + 0.01 corresponds to measurements in cents. + + bins_per_octave : int > 0 [scalar] + How many frequency bins per octave + + kwargs : additional keyword arguments + Additional arguments passed to `piptrack` + + Returns + ------- + tuning: float in `[-0.5, 0.5)` + estimated tuning deviation (fractions of a bin) + + See Also + -------- + piptrack + Pitch tracking by parabolic interpolation + + Examples + -------- + >>> # With time-series input + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.estimate_tuning(y=y, sr=sr) + 0.089999999999999969 + + >>> # In tenths of a cent + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.estimate_tuning(y=y, sr=sr, resolution=1e-3) + 0.093999999999999972 + + >>> # Using spectrogram input + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + >>> librosa.estimate_tuning(S=S, sr=sr) + 0.089999999999999969 + + >>> # Using pass-through arguments to `librosa.piptrack` + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.estimate_tuning(y=y, sr=sr, n_fft=8192, + ... fmax=librosa.note_to_hz('G#9')) + 0.070000000000000062 + + ''' + + pitch, mag = piptrack(y=y, sr=sr, S=S, n_fft=n_fft, **kwargs) + + # Only count magnitude where frequency is > 0 + pitch_mask = pitch > 0 + + if pitch_mask.any(): + threshold = np.median(mag[pitch_mask]) + else: + threshold = 0.0 + + return pitch_tuning(pitch[(mag >= threshold) & pitch_mask], + resolution=resolution, + bins_per_octave=bins_per_octave) + + +def pitch_tuning(frequencies, resolution=0.01, bins_per_octave=12): + '''Given a collection of pitches, estimate its tuning offset + (in fractions of a bin) relative to A440=440.0Hz. + + Parameters + ---------- + frequencies : array-like, float + A collection of frequencies detected in the signal. + See `piptrack` + + resolution : float in `(0, 1)` + Resolution of the tuning as a fraction of a bin. + 0.01 corresponds to cents. + + bins_per_octave : int > 0 [scalar] + How many frequency bins per octave + + Returns + ------- + tuning: float in `[-0.5, 0.5)` + estimated tuning deviation (fractions of a bin) + + See Also + -------- + estimate_tuning + Estimating tuning from time-series or spectrogram input + + Examples + -------- + >>> # Generate notes at +25 cents + >>> freqs = librosa.cqt_frequencies(24, 55, tuning=0.25) + >>> librosa.pitch_tuning(freqs) + 0.25 + + >>> # Track frequencies from a real spectrogram + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> pitches, magnitudes, stft = librosa.ifptrack(y, sr) + >>> # Select out pitches with high energy + >>> pitches = pitches[magnitudes > np.median(magnitudes)] + >>> librosa.pitch_tuning(pitches) + 0.089999999999999969 + + ''' + + frequencies = np.atleast_1d(frequencies) + + # Trim out any DC components + frequencies = frequencies[frequencies > 0] + + if not np.any(frequencies): + warnings.warn('Trying to estimate tuning from empty frequency set.') + return 0.0 + + # Compute the residual relative to the number of bins + residual = np.mod(bins_per_octave * + time_frequency.hz_to_octs(frequencies), 1.0) + + # Are we on the wrong side of the semitone? + # A residual of 0.95 is more likely to be a deviation of -0.05 + # from the next tone up. + residual[residual >= 0.5] -= 1.0 + + bins = np.linspace(-0.5, 0.5, np.ceil(1./resolution), endpoint=False) + + counts, tuning = np.histogram(residual, bins) + + # return the histogram peak + return tuning[np.argmax(counts)] + + +@cache +def piptrack(y=None, sr=22050, S=None, n_fft=2048, hop_length=None, + fmin=150.0, fmax=4000.0, threshold=0.1): + '''Pitch tracking on thresholded parabolically-interpolated STFT + + .. [1] https://ccrma.stanford.edu/~jos/sasp/Sinusoidal_Peak_Interpolation.html + + Parameters + ---------- + y: np.ndarray [shape=(n,)] or None + audio signal + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S: np.ndarray [shape=(d, t)] or None + magnitude or power spectrogram + + n_fft : int > 0 [scalar] or None + number of FFT bins to use, if `y` is provided. + + hop_length : int > 0 [scalar] or None + number of samples to hop + + threshold : float in `(0, 1)` + A bin in spectrum X is considered a pitch when it is greater than + `threshold*X.max()` + + fmin : float > 0 [scalar] + lower frequency cutoff. + + fmax : float > 0 [scalar] + upper frequency cutoff. + + .. note:: + One of `S` or `y` must be provided. + + If `S` is not given, it is computed from `y` using + the default parameters of `librosa.core.stft`. + + Returns + ------- + pitches : np.ndarray [shape=(d, t)] + magnitudes : np.ndarray [shape=(d,t)] + Where `d` is the subset of FFT bins within `fmin` and `fmax`. + + `pitches[f, t]` contains instantaneous frequency at bin + `f`, time `t` + + `magnitudes[f, t]` contains the corresponding magnitudes. + + Both `pitches` and `magnitudes` take value 0 at bins + of non-maximal magnitude. + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> pitches, magnitudes = librosa.piptrack(y=y, sr=sr) + + ''' + + # Check that we received an audio time series or STFT + if hop_length is None: + hop_length = int(n_fft // 4) + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + # Make sure we're dealing with magnitudes + S = np.abs(S) + + # Truncate to feasible region + fmin = np.maximum(fmin, 0) + fmax = np.minimum(fmax, float(sr) / 2) + + fft_freqs = time_frequency.fft_frequencies(sr=sr, n_fft=n_fft) + + # Do the parabolic interpolation everywhere, + # then figure out where the peaks are + # then restrict to the feasible range (fmin:fmax) + avg = 0.5 * (S[2:] - S[:-2]) + + shift = 2 * S[1:-1] - S[2:] - S[:-2] + + # Suppress divide-by-zeros. + # Points where shift == 0 will never be selected by localmax anyway + shift = avg / (shift + (np.abs(shift) < util.SMALL_FLOAT)) + + # Pad back up to the same shape as S + avg = np.pad(avg, ([1, 1], [0, 0]), mode='constant') + shift = np.pad(shift, ([1, 1], [0, 0]), mode='constant') + + dskew = 0.5 * avg * shift + + # Pre-allocate output + pitches = np.zeros_like(S) + mags = np.zeros_like(S) + + # Clip to the viable frequency range + freq_mask = ((fmin <= fft_freqs) & (fft_freqs < fmax)).reshape((-1, 1)) + + # Compute the column-wise local max of S after thresholding + # Find the argmax coordinates + idx = np.argwhere(freq_mask & + util.localmax(S * (S > (threshold * S.max(axis=0))))) + + # Store pitch and magnitude + pitches[idx[:, 0], idx[:, 1]] = ((idx[:, 0] + shift[idx[:, 0], idx[:, 1]]) + * float(sr) / n_fft) + + mags[idx[:, 0], idx[:, 1]] = (S[idx[:, 0], idx[:, 1]] + + dskew[idx[:, 0], idx[:, 1]]) + + return pitches, mags + + +# Deprecated functions below + +@util.decorators.deprecated('0.4', '0.5') +@cache +def ifptrack(y, sr=22050, n_fft=2048, hop_length=None, fmin=None, + fmax=None, threshold=0.75): # pragma: no cover + '''Instantaneous pitch frequency tracking. + + .. warning:: Deprecated in librosa 0.4 + `ifptrack` will be removed in 0.5. + See `piptrack` for comparable functionality. + + Parameters + ---------- + y: np.ndarray [shape=(n,)] + audio signal + + sr : number > 0 [scalar] + audio sampling rate of `y` + + n_fft: int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] or None + Hop size for STFT. Defaults to `n_fft / 4`. + See `librosa.core.stft` for details. + + threshold : float in `(0, 1)` + Maximum fraction of expected frequency increment to tolerate + + fmin : float or tuple of float + Ramp parameter for lower frequency cutoff. + + If scalar, the ramp has 0 width. + + If tuple, a linear ramp is applied from `fmin[0]` to `fmin[1]` + + Default: (150.0, 300.0) + + fmax : float or tuple of float + Ramp parameter for upper frequency cutoff. + + If scalar, the ramp has 0 width. + + If tuple, a linear ramp is applied from `fmax[0]` to `fmax[1]` + + Default: (2000.0, 4000.0) + + Returns + ------- + pitches : np.ndarray [shape=(d, t)] + magnitudes : np.ndarray [shape=(d, t)] + Where `d` is the subset of FFT bins within `fmin` and `fmax`. + + `pitches[i, t]` contains instantaneous frequencies at time `t` + + `magnitudes[i, t]` contains their magnitudes. + + D : np.ndarray [shape=(d, t), dtype=complex] + STFT matrix + + See Also + -------- + piptrack + librosa.core.stft + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> pitches, magnitudes, D = librosa.ifptrack(y, sr=sr) + + ''' + + if fmin is None: + fmin = (150.0, 300.0) + + if fmax is None: + fmax = (2000.0, 4000.0) + + fmin = np.atleast_1d(fmin) + fmax = np.atleast_1d(fmax) + + # Truncate to feasible region + fmin = np.maximum(0, fmin) + fmax = np.minimum(fmax, float(sr) / 2) + + # What's our DFT bin resolution? + fft_res = float(sr) / n_fft + + # Only look at bins up to 2 kHz + max_bin = int(round(fmax[-1] / fft_res)) + + if hop_length is None: + hop_length = int(n_fft // 4) + + # Calculate the inst freq gram + if_gram, D = ifgram(y, sr=sr, n_fft=n_fft, win_length=int(n_fft/2), + hop_length=hop_length) + + # Find plateaus in ifgram - stretches where delta IF is < thr: + # ie, places where the same frequency is spread across adjacent bins + idx_above = list(range(1, max_bin)) + [max_bin - 1] + idx_below = [0] + list(range(0, max_bin - 1)) + + # expected increment per bin = sr/w, threshold at 3/4 that + matches = (abs(if_gram[idx_above] - if_gram[idx_below]) + < (threshold * fft_res)) + + # mask out any singleton bins (where both above and below are zero) + matches = matches * ((matches[idx_above] > 0) | (matches[idx_below] > 0)) + + pitches = np.zeros_like(matches, dtype=float) + magnitudes = np.zeros_like(matches, dtype=float) + + # For each frame, extract all harmonic freqs & magnitudes + for t in range(matches.shape[1]): + + # find nonzero regions in this vector + # The mask selects out constant regions + active borders + mask = ~np.pad(matches[:, t], 1, mode='constant') + + starts = np.argwhere(matches[:, t] & mask[:-2]).astype(int) + ends = 1 + np.argwhere(matches[:, t] & mask[2:]).astype(int) + + # Set up inner loop + frqs = np.zeros_like(starts, dtype=float) + mags = np.zeros_like(starts, dtype=float) + + for i, (start_i, end_i) in enumerate(zip(starts, ends)): + + start_i = np.asscalar(start_i) + end_i = np.asscalar(end_i) + + # Weight frequencies by energy + weights = np.abs(D[start_i:end_i, t]) + mags[i] = weights.sum() + + # Compute the weighted average frequency. + # FIXME: is this the right thing to do? + # These are frequencies... shouldn't this be a + # weighted geometric average? + frqs[i] = weights.dot(if_gram[start_i:end_i, t]) + if mags[i] > 0: + frqs[i] /= mags[i] + + # Clip outside the ramp zones + idx = (fmax[-1] < frqs) | (frqs < fmin[0]) + mags[idx] = 0 + frqs[idx] = 0 + + # Ramp down at the high end + idx = (fmax[-1] > frqs) & (frqs > fmax[0]) + mags[idx] *= (fmax[-1] - frqs[idx]) / (fmax[-1] - fmax[0]) + + # Ramp up from the bottom end + idx = (fmin[-1] > frqs) & (frqs > fmin[0]) + mags[idx] *= (frqs[idx] - fmin[0]) / (fmin[-1] - fmin[0]) + + # Assign pitch and magnitude to their center bin + bins = (starts + ends) / 2 + pitches[bins, t] = frqs + magnitudes[bins, t] = mags + + return pitches, magnitudes, D diff --git a/librosa/core/spectrum.py b/librosa/core/spectrum.py new file mode 100644 index 0000000000..52cb718747 --- /dev/null +++ b/librosa/core/spectrum.py @@ -0,0 +1,1017 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +'''Utilities for spectral processing''' + +import numpy as np +import scipy.fftpack as fft +import scipy +import scipy.signal +import scipy.interpolate +import six + +from . import time_frequency +from .. import cache +from .. import util +from ..util.exceptions import ParameterError + +__all__ = ['stft', 'istft', 'magphase', + 'ifgram', + 'phase_vocoder', + 'logamplitude', 'perceptual_weighting', + 'fmt'] + + +@cache +def stft(y, n_fft=2048, hop_length=None, win_length=None, window=None, + center=True, dtype=np.complex64): + """Short-time Fourier transform (STFT) + + Returns a complex-valued matrix D such that + `np.abs(D[f, t])` is the magnitude of frequency bin `f` + at frame `t` + + `np.angle(D[f, t])` is the phase of frequency bin `f` + at frame `t` + + Parameters + ---------- + y : np.ndarray [shape=(n,)], real-valued + the input signal (audio time series) + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + number audio of frames between STFT columns. + If unspecified, defaults `win_length / 4`. + + win_length : int <= n_fft [scalar] + Each frame of audio is windowed by `window()`. + The window will be of length `win_length` and then padded + with zeros to match `n_fft`. + + If unspecified, defaults to ``win_length = n_fft``. + + window : None, function, np.ndarray [shape=(n_fft,)] + - None (default): use an asymmetric Hann window + - a window function, such as `scipy.signal.hanning` + - a vector or array of length `n_fft` + + center : boolean + - If `True`, the signal `y` is padded so that frame + `D[:, t]` is centered at `y[t * hop_length]`. + - If `False`, then `D[:, t]` begins at `y[t * hop_length]` + + dtype : numeric type + Complex numeric type for `D`. Default is 64-bit complex. + + + Returns + ------- + D : np.ndarray [shape=(1 + n_fft/2, t), dtype=dtype] + STFT matrix + + + Raises + ------ + ParameterError + If `window` is supplied as a vector of length `n_fft`. + + + See Also + -------- + istft : Inverse STFT + + ifgram : Instantaneous frequency spectrogram + + + Examples + -------- + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> D = librosa.stft(y) + >>> D + array([[ 2.576e-03 -0.000e+00j, 4.327e-02 -0.000e+00j, ..., + 3.189e-04 -0.000e+00j, -5.961e-06 -0.000e+00j], + [ 2.441e-03 +2.884e-19j, 5.145e-02 -5.076e-03j, ..., + -3.885e-04 -7.253e-05j, 7.334e-05 +3.868e-04j], + ..., + [ -7.120e-06 -1.029e-19j, -1.951e-09 -3.568e-06j, ..., + -4.912e-07 -1.487e-07j, 4.438e-06 -1.448e-05j], + [ 7.136e-06 -0.000e+00j, 3.561e-06 -0.000e+00j, ..., + -5.144e-07 -0.000e+00j, -1.514e-05 -0.000e+00j]], dtype=complex64) + + + Use left-aligned frames, instead of centered frames + + + >>> D_left = librosa.stft(y, center=False) + + + Use a shorter hop length + + + >>> D_short = librosa.stft(y, hop_length=64) + + + Display a spectrogram + + + >>> import matplotlib.pyplot as plt + >>> librosa.display.specshow(librosa.logamplitude(np.abs(D)**2, + ... ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('Power spectrogram') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.tight_layout() + + """ + + # By default, use the entire frame + if win_length is None: + win_length = n_fft + + # Set the default hop, if it's not already specified + if hop_length is None: + hop_length = int(win_length / 4) + + if window is None: + # Default is an asymmetric Hann window + fft_window = scipy.signal.hann(win_length, sym=False) + + elif six.callable(window): + # User supplied a window function + fft_window = window(win_length) + + else: + # User supplied a window vector. + # Make sure it's an array: + fft_window = np.asarray(window) + + # validate length compatibility + if fft_window.size != n_fft: + raise ParameterError('Size mismatch between n_fft and len(window)') + + # Pad the window out to n_fft size + fft_window = util.pad_center(fft_window, n_fft) + + # Reshape so that the window can be broadcast + fft_window = fft_window.reshape((-1, 1)) + + # Pad the time series so that frames are centered + if center: + util.valid_audio(y) + y = np.pad(y, int(n_fft // 2), mode='reflect') + + # Window the time series. + y_frames = util.frame(y, frame_length=n_fft, hop_length=hop_length) + + # Pre-allocate the STFT matrix + stft_matrix = np.empty((int(1 + n_fft // 2), y_frames.shape[1]), + dtype=dtype, + order='F') + + # how many columns can we fit within MAX_MEM_BLOCK? + n_columns = int(util.MAX_MEM_BLOCK / (stft_matrix.shape[0] * + stft_matrix.itemsize)) + + for bl_s in range(0, stft_matrix.shape[1], n_columns): + bl_t = min(bl_s + n_columns, stft_matrix.shape[1]) + + # RFFT and Conjugate here to match phase from DPWE code + stft_matrix[:, bl_s:bl_t] = fft.fft(fft_window * + y_frames[:, bl_s:bl_t], + axis=0)[:stft_matrix.shape[0]].conj() + + return stft_matrix + + +@cache +def istft(stft_matrix, hop_length=None, win_length=None, window=None, + center=True, dtype=np.float32): + """ + Inverse short-time Fourier transform (ISTFT). + + Converts a complex-valued spectrogram `stft_matrix` to time-series `y` + by minimizing the mean squared error between `stft_matrix` and STFT of + `y` as described in [1]_. + + In general, window function, hop length and other parameters should be same + as in stft, which mostly leads to perfect reconstruction of a signal from + unmodified `stft_matrix`. + + .. [1] D. W. Griffin and J. S. Lim, + "Signal estimation from modified short-time Fourier transform," + IEEE Trans. ASSP, vol.32, no.2, pp.236–243, Apr. 1984. + + Parameters + ---------- + stft_matrix : np.ndarray [shape=(1 + n_fft/2, t)] + STFT matrix from `stft` + + hop_length : int > 0 [scalar] + Number of frames between STFT columns. + If unspecified, defaults to `win_length / 4`. + + win_length : int <= n_fft = 2 * (stft_matrix.shape[0] - 1) + When reconstructing the time series, each frame is windowed + and each sample is normalized by the sum of squared window + according to the `window` function (see below). + + If unspecified, defaults to `n_fft`. + + window : None, function, np.ndarray [shape=(n_fft,)] + - None (default): use an asymmetric Hann window + - a window function, such as `scipy.signal.hanning` + - a user-specified window vector of length `n_fft` + + center : boolean + - If `True`, `D` is assumed to have centered frames. + - If `False`, `D` is assumed to have left-aligned frames. + + dtype : numeric type + Real numeric type for `y`. Default is 32-bit float. + + Returns + ------- + y : np.ndarray [shape=(n,)] + time domain signal reconstructed from `stft_matrix` + + Raises + ------ + ParameterError + If `window` is supplied as a vector of length `n_fft` + + See Also + -------- + stft : Short-time Fourier Transform + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> D = librosa.stft(y) + >>> y_hat = librosa.istft(D) + >>> y_hat + array([ -4.812e-06, -4.267e-06, ..., 6.271e-06, 2.827e-07], dtype=float32) + + Exactly preserving length of the input signal requires explicit padding. + Otherwise, a partial frame at the end of `y` will not be represented. + + >>> n = len(y) + >>> n_fft = 2048 + >>> y_pad = librosa.util.fix_length(y, n + n_fft // 2) + >>> D = librosa.stft(y_pad, n_fft=n_fft) + >>> y_out = librosa.util.fix_length(librosa.istft(D), n) + >>> np.max(np.abs(y - y_out)) + 1.4901161e-07 + """ + + n_fft = 2 * (stft_matrix.shape[0] - 1) + + # By default, use the entire frame + if win_length is None: + win_length = n_fft + + # Set the default hop, if it's not already specified + if hop_length is None: + hop_length = int(win_length / 4) + + if window is None: + # Default is an asymmetric Hann window. + ifft_window = scipy.signal.hann(win_length, sym=False) + + elif six.callable(window): + # User supplied a windowing function + ifft_window = window(win_length) + + else: + # User supplied a window vector. + # Make it into an array + ifft_window = np.asarray(window) + + # Verify that the shape matches + if ifft_window.size != n_fft: + raise ParameterError('Size mismatch between n_fft and window size') + + # Pad out to match n_fft + ifft_window = util.pad_center(ifft_window, n_fft) + + n_frames = stft_matrix.shape[1] + expected_signal_len = n_fft + hop_length * (n_frames - 1) + y = np.zeros(expected_signal_len, dtype=dtype) + ifft_window_sum = np.zeros(expected_signal_len, dtype=dtype) + ifft_window_square = ifft_window * ifft_window + + for i in range(n_frames): + sample = i * hop_length + spec = stft_matrix[:, i].flatten() + spec = np.concatenate((spec.conj(), spec[-2:0:-1]), 0) + ytmp = ifft_window * fft.ifft(spec).real + + y[sample:(sample + n_fft)] = y[sample:(sample + n_fft)] + ytmp + ifft_window_sum[sample:(sample + n_fft)] += ifft_window_square + + # Normalize by sum of squared window + approx_nonzero_indices = ifft_window_sum > util.SMALL_FLOAT + y[approx_nonzero_indices] /= ifft_window_sum[approx_nonzero_indices] + + if center: + y = y[int(n_fft // 2):-int(n_fft // 2)] + + return y + + +def ifgram(y, sr=22050, n_fft=2048, hop_length=None, win_length=None, + norm=False, center=True, ref_power=1e-6, clip=True, dtype=np.complex64): + '''Compute the instantaneous frequency (as a proportion of the sampling rate) + obtained as the time-derivative of the phase of the complex spectrum as + described by [1]_. + + Calculates regular STFT as a side effect. + + .. [1] Abe, Toshihiko, Takao Kobayashi, and Satoshi Imai. + "Harmonics tracking and pitch extraction based on instantaneous + frequency." + International Conference on Acoustics, Speech, and Signal Processing, + ICASSP-95., Vol. 1. IEEE, 1995. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length, number samples between subsequent frames. + If not supplied, defaults to `win_length / 4`. + + win_length : int > 0, <= n_fft + Window length. Defaults to `n_fft`. + See `stft` for details. + + norm : bool + Normalize the STFT. + + center : boolean + - If `True`, the signal `y` is padded so that frame + `D[:, t]` (and `if_gram`) is centered at `y[t * hop_length]`. + - If `False`, then `D[:, t]` at `y[t * hop_length]` + + ref_power : float >= 0 or callable + Minimum power threshold for estimating instantaneous frequency. + Any bin with `np.abs(D[f, t])**2 < ref_power` will receive the + default frequency estimate. + + If callable, the threshold is set to `ref_power(np.abs(D)**2)`. + + clip : boolean + - If `True`, clip estimated frequencies to the range `[0, 0.5 * sr]`. + - If `False`, estimated frequencies can be negative or exceed + `0.5 * sr`. + + dtype : numeric type + Complex numeric type for `D`. Default is 64-bit complex. + + Returns + ------- + if_gram : np.ndarray [shape=(1 + n_fft/2, t), dtype=real] + Instantaneous frequency spectrogram: + `if_gram[f, t]` is the frequency at bin `f`, time `t` + + D : np.ndarray [shape=(1 + n_fft/2, t), dtype=complex] + Short-time Fourier transform + + See Also + -------- + stft : Short-time Fourier Transform + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> frequencies, D = librosa.ifgram(y, sr=sr) + >>> frequencies + array([[ 0.000e+00, 0.000e+00, ..., 0.000e+00, 0.000e+00], + [ 3.150e+01, 3.070e+01, ..., 1.077e+01, 1.077e+01], + ..., + [ 1.101e+04, 1.101e+04, ..., 1.101e+04, 1.101e+04], + [ 1.102e+04, 1.102e+04, ..., 1.102e+04, 1.102e+04]]) + + ''' + + if win_length is None: + win_length = n_fft + + if hop_length is None: + hop_length = int(win_length // 4) + + # Construct a padded hann window + window = util.pad_center(scipy.signal.hann(win_length, sym=False), n_fft) + + # Window for discrete differentiation + freq_angular = np.linspace(0, 2 * np.pi, n_fft, endpoint=False) + + d_window = np.sin(-freq_angular) * np.pi / n_fft + + stft_matrix = stft(y, n_fft=n_fft, hop_length=hop_length, + window=window, center=center, dtype=dtype) + + diff_stft = stft(y, n_fft=n_fft, hop_length=hop_length, + window=d_window, center=center, dtype=dtype).conj() + + # Compute power normalization. Suppress zeros. + mag, phase = magphase(stft_matrix) + + if six.callable(ref_power): + ref_power = ref_power(mag**2) + elif ref_power < 0: + raise ParameterError('ref_power must be non-negative or callable.') + + # Pylint does not correctly infer the type here, but it's correct. + # pylint: disable=maybe-no-member + freq_angular = freq_angular.reshape((-1, 1)) + bin_offset = (phase * diff_stft).imag / mag + + bin_offset[mag < ref_power**0.5] = 0 + + if_gram = freq_angular[:n_fft//2 + 1] + bin_offset + + if norm: + stft_matrix = stft_matrix * 2.0 / window.sum() + + if clip: + np.clip(if_gram, 0, np.pi, out=if_gram) + + if_gram *= float(sr) * 0.5 / np.pi + + return if_gram, stft_matrix + + +def magphase(D): + """Separate a complex-valued spectrogram D into its magnitude (S) + and phase (P) components, so that `D = S * P`. + + + Parameters + ---------- + D : np.ndarray [shape=(d, t), dtype=complex] + complex-valued spectrogram + + + Returns + ------- + D_mag : np.ndarray [shape=(d, t), dtype=real] + magnitude of `D` + D_phase : np.ndarray [shape=(d, t), dtype=complex] + `exp(1.j * phi)` where `phi` is the phase of `D` + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> D = librosa.stft(y) + >>> magnitude, phase = librosa.magphase(D) + >>> magnitude + array([[ 2.524e-03, 4.329e-02, ..., 3.217e-04, 3.520e-05], + [ 2.645e-03, 5.152e-02, ..., 3.283e-04, 3.432e-04], + ..., + [ 1.966e-05, 9.828e-06, ..., 3.164e-07, 9.370e-06], + [ 1.966e-05, 9.830e-06, ..., 3.161e-07, 9.366e-06]], dtype=float32) + >>> phase + array([[ 1.000e+00 +0.000e+00j, 1.000e+00 +0.000e+00j, ..., + -1.000e+00 +8.742e-08j, -1.000e+00 +8.742e-08j], + [ 1.000e+00 +1.615e-16j, 9.950e-01 -1.001e-01j, ..., + 9.794e-01 +2.017e-01j, 1.492e-02 -9.999e-01j], + ..., + [ 1.000e+00 -5.609e-15j, -5.081e-04 +1.000e+00j, ..., + -9.549e-01 -2.970e-01j, 2.938e-01 -9.559e-01j], + [ -1.000e+00 +8.742e-08j, -1.000e+00 +8.742e-08j, ..., + -1.000e+00 +8.742e-08j, -1.000e+00 +8.742e-08j]], dtype=complex64) + + + Or get the phase angle (in radians) + + >>> np.angle(phase) + array([[ 0.000e+00, 0.000e+00, ..., 3.142e+00, 3.142e+00], + [ 1.615e-16, -1.003e-01, ..., 2.031e-01, -1.556e+00], + ..., + [ -5.609e-15, 1.571e+00, ..., -2.840e+00, -1.273e+00], + [ 3.142e+00, 3.142e+00, ..., 3.142e+00, 3.142e+00]], dtype=float32) + + """ + + mag = np.abs(D) + phase = np.exp(1.j * np.angle(D)) + + return mag, phase + + +@cache +def phase_vocoder(D, rate, hop_length=None): + """Phase vocoder. Given an STFT matrix D, speed up by a factor of `rate` + + Based on the implementation provided by [1]_. + + .. [1] Ellis, D. P. W. "A phase vocoder in Matlab." + Columbia University, 2002. + http://www.ee.columbia.edu/~dpwe/resources/matlab/pvoc/ + + Examples + -------- + >>> # Play at double speed + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> D = librosa.stft(y, n_fft=2048, hop_length=512) + >>> D_fast = librosa.phase_vocoder(D, 2.0, hop_length=512) + >>> y_fast = librosa.istft(D_fast, hop_length=512) + + >>> # Or play at 1/3 speed + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> D = librosa.stft(y, n_fft=2048, hop_length=512) + >>> D_slow = librosa.phase_vocoder(D, 1./3, hop_length=512) + >>> y_slow = librosa.istft(D_slow, hop_length=512) + + Parameters + ---------- + D : np.ndarray [shape=(d, t), dtype=complex] + STFT matrix + + rate : float > 0 [scalar] + Speed-up factor: `rate > 1` is faster, `rate < 1` is slower. + + hop_length : int > 0 [scalar] or None + The number of samples between successive columns of `D`. + + If None, defaults to `n_fft/4 = (D.shape[0]-1)/2` + + Returns + ------- + D_stretched : np.ndarray [shape=(d, t / rate), dtype=complex] + time-stretched STFT + """ + + n_fft = 2 * (D.shape[0] - 1) + + if hop_length is None: + hop_length = int(n_fft // 4) + + time_steps = np.arange(0, D.shape[1], rate, dtype=np.float) + + # Create an empty output array + d_stretch = np.zeros((D.shape[0], len(time_steps)), D.dtype, order='F') + + # Expected phase advance in each bin + phi_advance = np.linspace(0, np.pi * hop_length, D.shape[0]) + + # Phase accumulator; initialize to the first sample + phase_acc = np.angle(D[:, 0]) + + # Pad 0 columns to simplify boundary logic + D = np.pad(D, [(0, 0), (0, 2)], mode='constant') + + for (t, step) in enumerate(time_steps): + + columns = D[:, int(step):int(step + 2)] + + # Weighting for linear magnitude interpolation + alpha = np.mod(step, 1.0) + mag = ((1.0 - alpha) * np.abs(columns[:, 0]) + + alpha * np.abs(columns[:, 1])) + + # Store to output array + d_stretch[:, t] = mag * np.exp(1.j * phase_acc) + + # Compute phase advance + dphase = (np.angle(columns[:, 1]) + - np.angle(columns[:, 0]) + - phi_advance) + + # Wrap to -pi:pi range + dphase = dphase - 2.0 * np.pi * np.round(dphase / (2.0 * np.pi)) + + # Accumulate phase + phase_acc += phi_advance + dphase + + return d_stretch + + +@cache +def logamplitude(S, ref_power=1.0, amin=1e-10, top_db=80.0): + """Log-scale the amplitude of a spectrogram. + + Parameters + ---------- + S : np.ndarray [shape=(d, t)] + input spectrogram + + ref_power : scalar or function + If scalar, `log(abs(S))` is compared to `log(ref_power)`. + + If a function, `log(abs(S))` is compared to `log(ref_power(abs(S)))`. + + This is primarily useful for comparing to the maximum value of `S`. + + amin : float > 0[scalar] + minimum amplitude threshold for `abs(S)` and `ref_power` + + top_db : float >= 0 [scalar] + threshold log amplitude at top_db below the peak: + ``max(log(S)) - top_db`` + + Returns + ------- + log_S : np.ndarray [shape=(d, t)] + ``log_S ~= 10 * log10(S) - 10 * log10(abs(ref_power))`` + + See Also + -------- + perceptual_weighting + + Examples + -------- + Get a power spectrogram from a waveform ``y`` + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + >>> librosa.logamplitude(S**2) + array([[-33.293, -27.32 , ..., -33.293, -33.293], + [-33.293, -25.723, ..., -33.293, -33.293], + ..., + [-33.293, -33.293, ..., -33.293, -33.293], + [-33.293, -33.293, ..., -33.293, -33.293]], dtype=float32) + + Compute dB relative to peak power + + >>> librosa.logamplitude(S**2, ref_power=np.max) + array([[-80. , -74.027, ..., -80. , -80. ], + [-80. , -72.431, ..., -80. , -80. ], + ..., + [-80. , -80. , ..., -80. , -80. ], + [-80. , -80. , ..., -80. , -80. ]], dtype=float32) + + + Or compare to median power + + >>> librosa.logamplitude(S**2, ref_power=np.median) + array([[-0.189, 5.784, ..., -0.189, -0.189], + [-0.189, 7.381, ..., -0.189, -0.189], + ..., + [-0.189, -0.189, ..., -0.189, -0.189], + [-0.189, -0.189, ..., -0.189, -0.189]], dtype=float32) + + + And plot the results + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(S**2, sr=sr, y_axis='log', x_axis='time') + >>> plt.colorbar() + >>> plt.title('Power spectrogram') + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... sr=sr, y_axis='log', x_axis='time') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Log-Power spectrogram') + >>> plt.tight_layout() + + """ + + if amin <= 0: + raise ParameterError('amin must be strictly positive') + + magnitude = np.abs(S) + + if six.callable(ref_power): + # User supplied a function to calculate reference power + __ref = ref_power(magnitude) + else: + __ref = np.abs(ref_power) + + log_spec = 10.0 * np.log10(np.maximum(amin, magnitude)) + log_spec -= 10.0 * np.log10(np.maximum(amin, __ref)) + + if top_db is not None: + if top_db < 0: + raise ParameterError('top_db must be non-negative positive') + log_spec = np.maximum(log_spec, log_spec.max() - top_db) + + return log_spec + + +@cache +def perceptual_weighting(S, frequencies, **kwargs): + '''Perceptual weighting of a power spectrogram: + + `S_p[f] = A_weighting(f) + 10*log(S[f] / ref_power)` + + Parameters + ---------- + S : np.ndarray [shape=(d, t)] + Power spectrogram + + frequencies : np.ndarray [shape=(d,)] + Center frequency for each row of `S` + + kwargs : additional keyword arguments + Additional keyword arguments to `logamplitude`. + + Returns + ------- + S_p : np.ndarray [shape=(d, t)] + perceptually weighted version of `S` + + See Also + -------- + logamplitude + + Examples + -------- + Re-weight a CQT power spectrum, using peak power as reference + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> CQT = librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('A1')) + >>> freqs = librosa.cqt_frequencies(CQT.shape[0], + ... fmin=librosa.note_to_hz('A1')) + >>> perceptual_CQT = librosa.perceptual_weighting(CQT**2, + ... freqs, + ... ref_power=np.max) + >>> perceptual_CQT + array([[ -80.076, -80.049, ..., -104.735, -104.735], + [ -78.344, -78.555, ..., -103.725, -103.725], + ..., + [ -76.272, -76.272, ..., -76.272, -76.272], + [ -76.485, -76.485, ..., -76.485, -76.485]]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(CQT**2, + ... ref_power=np.max), + ... fmin=librosa.note_to_hz('A1'), + ... y_axis='cqt_hz', + ... x_axis='time') + >>> plt.title('Log CQT power') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(perceptual_CQT, y_axis='cqt_hz', + ... fmin=librosa.note_to_hz('A1'), + ... x_axis='time') + >>> plt.title('Perceptually weighted log CQT') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.tight_layout() + ''' + + offset = time_frequency.A_weighting(frequencies).reshape((-1, 1)) + + return offset + logamplitude(S, **kwargs) + + +@cache +def fmt(y, t_min=0.5, n_fmt=None, kind='cubic', beta=0.5, over_sample=1, axis=-1): + """The fast Mellin transform (FMT) [1]_ of a uniformly sampled signal y. + + When the Mellin parameter (beta) is 1/2, it is also known as the scale transform [2]_. + The scale transform can be useful for audio analysis because its magnitude is invariant + to scaling of the domain (e.g., time stretching or compression). This is analogous + to the magnitude of the Fourier transform being invariant to shifts in the input domain. + + + .. [1] De Sena, Antonio, and Davide Rocchesso. + "A fast Mellin and scale transform." + EURASIP Journal on Applied Signal Processing 2007.1 (2007): 75-75. + + .. [2] Cohen, L. + "The scale representation." + IEEE Transactions on Signal Processing 41, no. 12 (1993): 3275-3292. + + Parameters + ---------- + y : np.ndarray, real-valued + The input signal(s). Can be multidimensional. + The target axis must contain at least 3 samples. + + t_min : float > 0 + The minimum time spacing (in samples). + This value should generally be less than 1 to preserve as much information as + possible. + + n_fmt : int > 2 or None + The number of scale transform bins to use. + If None, then `n_bins = over_sample * ceil(n * log((n-1)/t_min))` is taken, + where `n = y.shape[axis]` + + kind : str + The type of interpolation to use when re-sampling the input. + See `scipy.interpolate.interp1d` for possible values. + + beta : float + The Mellin parameter. beta=0.5 provides the scale transform. + + over_sample : float >= 1 + Over-sampling factor for exponential resampling. + + axis : int + The axis along which to transform `y` + + Returns + ------- + x_scale : np.ndarray [dtype=complex] + The scale transform of `y` along the `axis` dimension. + + Raises + ------ + ParameterError + if `n_fmt < 2` or `t_min <= 0` + or if `y` is not finite + or if `y.shape[axis] < 3`. + + Examples + -------- + >>> # Generate a signal and time-stretch it (with energy normalization) + >>> scale = 1.25 + >>> freq = 3.0 + >>> x1 = np.linspace(0, 1, num=1024, endpoint=False) + >>> x2 = np.linspace(0, 1, num=scale * len(x1), endpoint=False) + >>> y1 = np.sin(2 * np.pi * freq * x1) + >>> y2 = np.sin(2 * np.pi * freq * x2) / np.sqrt(scale) + >>> # Verify that the two signals have the same energy + >>> np.sum(np.abs(y1)**2), np.sum(np.abs(y2)**2) + (255.99999999999997, 255.99999999999969) + >>> scale1 = librosa.fmt(y1, n_fmt=512) + >>> scale2 = librosa.fmt(y2, n_fmt=512) + >>> # And plot the results + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(8, 4)) + >>> plt.subplot(1, 2, 1) + >>> plt.plot(y1, label='Original') + >>> plt.plot(y2, linestyle='--', label='Stretched') + >>> plt.xlabel('time (samples)') + >>> plt.title('Input signals') + >>> plt.legend(frameon=True) + >>> plt.axis('tight') + >>> plt.subplot(1, 2, 2) + >>> plt.semilogy(np.abs(scale1), label='Original') + >>> plt.semilogy(np.abs(scale2), linestyle='--', label='Stretched') + >>> plt.xlabel('scale coefficients') + >>> plt.title('Scale transform magnitude') + >>> plt.legend(frameon=True) + >>> plt.axis('tight') + >>> plt.tight_layout() + + >>> # Plot the scale transform of an onset strength autocorrelation + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... offset=10.0, duration=30.0) + >>> odf = librosa.onset.onset_strength(y=y, sr=sr) + >>> # Auto-correlate with up to 10 seconds lag + >>> odf_ac = librosa.autocorrelate(odf, max_size=10 * sr // 512) + >>> # Normalize + >>> odf_ac = librosa.util.normalize(odf_ac, norm=np.inf) + >>> # Compute the scale transform + >>> odf_ac_scale = librosa.fmt(librosa.util.normalize(odf_ac), n_fmt=512) + >>> # Plot the results + >>> plt.figure() + >>> plt.subplot(3, 1, 1) + >>> plt.plot(odf, label='Onset strength') + >>> plt.axis('tight') + >>> plt.xlabel('Time (frames)') + >>> plt.xticks([]) + >>> plt.legend(frameon=True) + >>> plt.subplot(3, 1, 2) + >>> plt.plot(odf_ac, label='Onset autocorrelation') + >>> plt.axis('tight') + >>> plt.xlabel('Lag (frames)') + >>> plt.xticks([]) + >>> plt.legend(frameon=True) + >>> plt.subplot(3, 1, 3) + >>> plt.semilogy(np.abs(odf_ac_scale), label='Scale transform magnitude') + >>> plt.axis('tight') + >>> plt.xlabel('scale coefficients') + >>> plt.legend(frameon=True) + >>> plt.tight_layout() + """ + + n = y.shape[axis] + + if n < 3: + raise ParameterError('y.shape[{:}]=={:} < 3'.format(axis, n)) + + if t_min <= 0: + raise ParameterError('t_min must be a positive number') + + + if n_fmt is None: + if over_sample < 1: + raise ParameterError('over_sample must be >= 1') + + # The base is the maximum ratio between adjacent samples + # Since the sample spacing is increasing, this is simply the + # ratio between the positions of the last two samples: (n-1)/(n-2) + log_base = np.log(n - 1) - np.log(n - 2) + + n_fmt = int(np.ceil(over_sample * (np.log(n - 1) - np.log(t_min)) / log_base)) + + elif n_fmt < 3: + raise ParameterError('n_fmt=={:} < 3'.format(n_fmt)) + else: + log_base = (np.log(n_fmt - 1) - np.log(n_fmt - 2)) / over_sample + + if not np.all(np.isfinite(y)): + raise ParameterError('y must be finite everywhere') + + base = np.exp(log_base) + # original grid: signal covers [0, 1). This range is arbitrary, but convenient. + # The final sample is positioned at (n-1)/n, so we omit the endpoint + x = np.linspace(0, 1, num=n, endpoint=False) + + # build the interpolator + f_interp = scipy.interpolate.interp1d(x, y, kind=kind, axis=axis) + + # build the new sampling grid + # exponentially spaced between t_min/n and 1 (exclusive) + # we'll go one past where we need, and drop the last sample + # When over-sampling, the last input sample contributions n_over samples. + # To keep the spacing consistent, we over-sample by n_over, and then + # trim the final samples. + n_over = int(np.ceil(over_sample)) + x_exp = np.logspace((np.log(t_min) - np.log(n)) / log_base, + 0, + num=n_fmt + n_over, + endpoint=False, + base=base)[:-n_over] + + # Clean up any rounding errors at the boundaries of the interpolation + # The interpolator gets angry if we try to extrapolate, so clipping is necessary here. + if x_exp[0] < t_min or x_exp[-1] > float(n - 1.0) / n: + x_exp = np.clip(x_exp, float(t_min) / n, x[-1]) + + # Make sure that all sample points are unique + assert len(np.unique(x_exp)) == len(x_exp) + + # Resample the signal + y_res = f_interp(x_exp) + + # Broadcast the window correctly + shape = [1] * y_res.ndim + shape[axis] = -1 + + # Apply the window and fft + result = fft.fft(y_res * (x_exp**beta).reshape(shape), + axis=axis, overwrite_x=True) + + # Slice out the positive-scale component + idx = [slice(None)] * result.ndim + idx[axis] = slice(0, 1 + n_fmt//2) + + # Truncate and length-normalize + return result[idx] * np.sqrt(n) / n_fmt + + +@cache +def _spectrogram(y=None, S=None, n_fft=2048, hop_length=512, power=1): + '''Helper function to retrieve a magnitude spectrogram. + + This is primarily used in feature extraction functions that can operate on + either audio time-series or spectrogram input. + + + Parameters + ---------- + y : None or np.ndarray [ndim=1] + If provided, an audio time series + + S : None or np.ndarray + Spectrogram input, optional + + n_fft : int > 0 + STFT window size + + hop_length : int > 0 + STFT hop length + + power : float > 0 + Exponent for the magnitude spectrogram, + e.g., 1 for energy, 2 for power, etc. + + Returns + ------- + S_out : np.ndarray [dtype=np.float32] + - If `S` is provided as input, then `S_out == S` + - Else, `S_out = |stft(y, n_fft=n_fft, hop_length=hop_length)|**power` + + n_fft : int > 0 + - If `S` is provided, then `n_fft` is inferred from `S` + - Else, copied from input + ''' + + if S is not None: + # Infer n_fft from spectrogram shape + n_fft = 2 * (S.shape[0] - 1) + else: + # Otherwise, compute a magnitude spectrogram from input + S = np.abs(stft(y, n_fft=n_fft, hop_length=hop_length))**power + + return S, n_fft diff --git a/librosa/core/time_frequency.py b/librosa/core/time_frequency.py new file mode 100644 index 0000000000..1c090f8cbf --- /dev/null +++ b/librosa/core/time_frequency.py @@ -0,0 +1,919 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +'''Time and frequency utilities''' + +import numpy as np +import re +import six + +from ..util.exceptions import ParameterError + +__all__ = ['frames_to_samples', 'frames_to_time', + 'samples_to_frames', 'samples_to_time', + 'time_to_samples', 'time_to_frames', + 'note_to_hz', 'note_to_midi', + 'midi_to_hz', 'midi_to_note', + 'hz_to_note', 'hz_to_midi', + 'hz_to_mel', 'hz_to_octs', + 'mel_to_hz', + 'octs_to_hz', + 'fft_frequencies', + 'cqt_frequencies', + 'mel_frequencies', + 'A_weighting'] + + +def frames_to_samples(frames, hop_length=512, n_fft=None): + """Converts frame indices to audio sample indices + + Parameters + ---------- + frames : np.ndarray [shape=(n,)] + vector of frame indices + + hop_length : int > 0 [scalar] + number of samples between successive frames + + n_fft : None or int > 0 [scalar] + Optional: length of the FFT window. + If given, time conversion will include an offset of `n_fft / 2` + to counteract windowing effects when using a non-centered STFT. + + Returns + ------- + times : np.ndarray [shape=(n,)] + time (in seconds) of each given frame number: + `times[i] = frames[i] * hop_length` + + See Also + -------- + frames_to_time : convert frame indices to time values + samples_to_frames : convert sample indices to frame indices + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y, sr=sr) + >>> beat_samples = librosa.frames_to_samples(beats) + """ + + offset = 0 + if n_fft is not None: + offset = int(n_fft // 2) + + return (np.atleast_1d(frames) * hop_length + offset).astype(int) + + +def samples_to_frames(samples, hop_length=512, n_fft=None): + """Converts sample indices into STFT frames. + + Examples + -------- + >>> # Get the frame numbers for every 256 samples + >>> librosa.samples_to_frames(np.arange(0, 22050, 256)) + array([ 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, + 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, + 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, + 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, 34, 34, + 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40, 40, 41, 41, + 42, 42, 43]) + + Parameters + ---------- + samples : np.ndarray [shape=(n,)] + vector of sample indices + + hop_length : int > 0 [scalar] + number of samples between successive frames + + n_fft : None or int > 0 [scalar] + Optional: length of the FFT window. + If given, time conversion will include an offset of `- n_fft / 2` + to counteract windowing effects in STFT. + + .. note:: This may result in negative frame indices. + + Returns + ------- + frames : np.ndarray [shape=(n,), dtype=int] + Frame numbers corresponding to the given times: + `frames[i] = floor( samples[i] / hop_length )` + + See Also + -------- + samples_to_time : convert sample indices to time values + frames_to_samples : convert frame indices to sample indices + """ + + offset = 0 + if n_fft is not None: + offset = int(n_fft // 2) + + samples = np.atleast_1d(samples) + return np.floor((samples - offset) // hop_length).astype(int) + + +def frames_to_time(frames, sr=22050, hop_length=512, n_fft=None): + """Converts frame counts to time (seconds) + + Parameters + ---------- + frames : np.ndarray [shape=(n,)] + vector of frame numbers + + sr : number > 0 [scalar] + audio sampling rate + + hop_length : int > 0 [scalar] + number of samples between successive frames + + n_fft : None or int > 0 [scalar] + Optional: length of the FFT window. + If given, time conversion will include an offset of `n_fft / 2` + to counteract windowing effects when using a non-centered STFT. + + Returns + ------- + times : np.ndarray [shape=(n,)] + time (in seconds) of each given frame number: + `times[i] = frames[i] * hop_length / sr` + + See Also + -------- + time_to_frames : convert time values to frame indices + frames_to_samples : convert frame indices to sample indices + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y, sr=sr) + >>> beat_times = librosa.frames_to_time(beats, sr=sr) + """ + + samples = frames_to_samples(frames, + hop_length=hop_length, + n_fft=n_fft) + + return samples_to_time(samples, sr=sr) + + +def time_to_frames(times, sr=22050, hop_length=512, n_fft=None): + """Converts time stamps into STFT frames. + + Parameters + ---------- + times : np.ndarray [shape=(n,)] + vector of time stamps + + sr : number > 0 [scalar] + audio sampling rate + + hop_length : int > 0 [scalar] + number of samples between successive frames + + n_fft : None or int > 0 [scalar] + Optional: length of the FFT window. + If given, time conversion will include an offset of `- n_fft / 2` + to counteract windowing effects in STFT. + + .. note:: This may result in negative frame indices. + + Returns + ------- + frames : np.ndarray [shape=(n,), dtype=int] + Frame numbers corresponding to the given times: + `frames[i] = floor( times[i] * sr / hop_length )` + + See Also + -------- + frames_to_time : convert frame indices to time values + time_to_samples : convert time values to sample indices + + Examples + -------- + Get the frame numbers for every 100ms + + >>> librosa.time_to_frames(np.arange(0, 1, 0.1), + ... sr=22050, hop_length=512) + array([ 0, 4, 8, 12, 17, 21, 25, 30, 34, 38]) + + """ + + samples = time_to_samples(times, sr=sr) + + return samples_to_frames(samples, hop_length=hop_length, n_fft=n_fft) + + +def time_to_samples(times, sr=22050): + '''Convert timestamps (in seconds) to sample indices. + + Parameters + ---------- + times : np.ndarray + Array of time values (in seconds) + + sr : number > 0 + Sampling rate + + Returns + ------- + samples : np.ndarray [shape=times.shape, dtype=int] + Sample indices corresponding to values in `times` + + See Also + -------- + time_to_frames : convert time values to frame indices + samples_to_time : convert sample indices to time values + + Examples + -------- + >>> librosa.time_to_samples(np.arange(0, 1, 0.1), sr=22050) + array([ 0, 2205, 4410, 6615, 8820, 11025, 13230, 15435, + 17640, 19845]) + + ''' + + return (np.atleast_1d(times) * sr).astype(int) + + +def samples_to_time(samples, sr=22050): + '''Convert sample indices to time (in seconds). + + Parameters + ---------- + samples : np.ndarray + Array of sample indices + + sr : number > 0 + Sampling rate + + Returns + ------- + times : np.ndarray [shape=samples.shape, dtype=int] + Time values corresponding to `samples` (in seconds) + + See Also + -------- + samples_to_frames : convert sample indices to frame indices + time_to_samples : convert time values to sample indices + + Examples + -------- + Get timestamps corresponding to every 512 samples + + >>> librosa.samples_to_time(np.arange(0, 22050, 512)) + array([ 0. , 0.023, 0.046, 0.07 , 0.093, 0.116, 0.139, + 0.163, 0.186, 0.209, 0.232, 0.255, 0.279, 0.302, + 0.325, 0.348, 0.372, 0.395, 0.418, 0.441, 0.464, + 0.488, 0.511, 0.534, 0.557, 0.58 , 0.604, 0.627, + 0.65 , 0.673, 0.697, 0.72 , 0.743, 0.766, 0.789, + 0.813, 0.836, 0.859, 0.882, 0.906, 0.929, 0.952, + 0.975, 0.998]) + ''' + + return np.atleast_1d(samples) / float(sr) + + +def note_to_hz(note, **kwargs): + '''Convert one or more note names to frequency (Hz) + + Examples + -------- + >>> # Get the frequency of a note + >>> librosa.note_to_hz('C') + array([ 16.352]) + >>> # Or multiple notes + >>> librosa.note_to_hz(['A3', 'A4', 'A5']) + array([ 220., 440., 880.]) + >>> # Or notes with tuning deviations + >>> librosa.note_to_hz('C2-32', round_midi=False) + array([ 64.209]) + + Parameters + ---------- + note : str or iterable of str + One or more note names to convert + + kwargs : additional keyword arguments + Additional parameters to `note_to_midi` + + Returns + ------- + frequencies : np.ndarray [shape=(len(note),)] + Array of frequencies (in Hz) corresponding to `note` + + See Also + -------- + midi_to_hz + note_to_midi + hz_to_note + ''' + return midi_to_hz(note_to_midi(note, **kwargs)) + + +def note_to_midi(note, round_midi=True): + '''Convert one or more spelled notes to MIDI number(s). + + Notes may be spelled out with optional accidentals or octave numbers. + + The leading note name is case-insensitive. + + Sharps are indicated with ``#``, flats may be indicated with ``!`` or ``b``. + + Parameters + ---------- + note : str or iterable of str + One or more note names. + + round_midi : bool + - If `True`, allow for fractional midi notes + - Otherwise, round cent deviations to the nearest note + + Returns + ------- + midi : float or np.array + Midi note numbers corresponding to inputs. + + Raises + ------ + ParameterError + If the input is not in valid note format + + See Also + -------- + midi_to_note + note_to_hz + + Examples + -------- + >>> librosa.note_to_midi('C') + 12 + >>> librosa.note_to_midi('C#3') + 49 + >>> librosa.note_to_midi('f4') + 65 + >>> librosa.note_to_midi('Bb-1') + 10 + >>> librosa.note_to_midi('A!8') + 116 + >>> # Lists of notes also work + >>> librosa.note_to_midi(['C', 'E', 'G']) + array([12, 16, 19]) + + ''' + + if not isinstance(note, six.string_types): + return np.array([note_to_midi(n, round_midi=round_midi) for n in note]) + + pitch_map = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11} + acc_map = {'#': 1, '': 0, 'b': -1, '!': -1} + + match = re.match(r'^(?P[A-Ga-g])' + r'(?P[#b!]*)' + r'(?P[+-]?\d+)?' + r'(?P[+-]\d+)?$', + note) + if not match: + raise ParameterError('Improper note format: {:s}'.format(note)) + + pitch = match.group('note').upper() + offset = np.sum([acc_map[o] for o in match.group('accidental')]) + octave = match.group('octave') + cents = match.group('cents') + + if not octave: + octave = 0 + else: + octave = int(octave) + + if not cents: + cents = 0 + else: + cents = int(cents) * 1e-2 + + note_value = 12 * (octave + 1) + pitch_map[pitch] + offset + cents + + if round_midi: + note_value = int(np.round(note_value)) + + return note_value + + +def midi_to_note(midi, octave=True, cents=False): + '''Convert one or more MIDI numbers to note strings. + + MIDI numbers will be rounded to the nearest integer. + + Notes will be of the format 'C0', 'C#0', 'D0', ... + + Examples + -------- + >>> librosa.midi_to_note(0) + 'C-1' + >>> librosa.midi_to_note(37) + 'C#2' + >>> librosa.midi_to_note(-2) + 'A#-2' + >>> librosa.midi_to_note(104.7) + 'A7' + >>> librosa.midi_to_note(104.7, cents=True) + 'A7-30' + >>> librosa.midi_to_note(list(range(12, 24))) + ['C0', 'C#0', 'D0', 'D#0', 'E0', 'F0', 'F#0', 'G0', 'G#0', 'A0', 'A#0', 'B0'] + + Parameters + ---------- + midi : int or iterable of int + Midi numbers to convert. + + octave: bool + If True, include the octave number + + cents: bool + If true, cent markers will be appended for fractional notes. + Eg, `midi_to_note(69.3, cents=True)` == `A4+03` + + Returns + ------- + notes : str or iterable of str + Strings describing each midi note. + + Raises + ------ + ParameterError + if `cents` is True and `octave` is False + + See Also + -------- + midi_to_hz + note_to_midi + hz_to_note + ''' + + if cents and not octave: + raise ParameterError('Cannot encode cents without octave information.') + + if not np.isscalar(midi): + return [midi_to_note(x, octave=octave, cents=cents) for x in midi] + + note_map = ['C', 'C#', 'D', 'D#', + 'E', 'F', 'F#', 'G', + 'G#', 'A', 'A#', 'B'] + + note_num = int(np.round(midi)) + note_cents = int(100 * np.around(midi - note_num, 2)) + + note = note_map[note_num % 12] + + if octave: + note = '{:s}{:0d}'.format(note, int(note_num / 12) - 1) + if cents: + note = '{:s}{:+02d}'.format(note, note_cents) + + return note + + +def midi_to_hz(notes): + """Get the frequency (Hz) of MIDI note(s) + + Examples + -------- + >>> librosa.midi_to_hz(36) + array([ 65.406]) + + >>> librosa.midi_to_hz(np.arange(36, 48)) + array([ 65.406, 69.296, 73.416, 77.782, 82.407, + 87.307, 92.499, 97.999, 103.826, 110. , + 116.541, 123.471]) + + Parameters + ---------- + notes : int or np.ndarray [shape=(n,), dtype=int] + midi number(s) of the note(s) + + Returns + ------- + frequency : np.ndarray [shape=(n,), dtype=float] + frequency (frequencies) of `notes` in Hz + + See Also + -------- + hz_to_midi + note_to_hz + """ + + return 440.0 * (2.0 ** ((np.atleast_1d(notes) - 69.0)/12.0)) + + +def hz_to_midi(frequencies): + """Get the closest MIDI note number(s) for given frequencies + + Examples + -------- + >>> librosa.hz_to_midi(60) + array([ 34.506]) + >>> librosa.hz_to_midi([110, 220, 440]) + array([ 45., 57., 69.]) + + Parameters + ---------- + frequencies : float or np.ndarray [shape=(n,), dtype=float] + frequencies to convert + + Returns + ------- + note_nums : np.ndarray [shape=(n,), dtype=int] + closest MIDI notes to `frequencies` + + See Also + -------- + midi_to_hz + note_to_midi + hz_to_note + """ + + return 12 * (np.log2(np.atleast_1d(frequencies)) - np.log2(440.0)) + 69 + + +def hz_to_note(frequencies, **kwargs): + '''Convert one or more frequencies (in Hz) to the nearest note names. + + Parameters + ---------- + frequencies : float or iterable of float + Input frequencies, specified in Hz + + kwargs : additional keyword arguments + Arguments passed through to `midi_to_note` + + + Returns + ------- + notes : list of str + `notes[i]` is the closest note name to `frequency[i]` + (or `frequency` if the input is scalar) + + + See Also + -------- + hz_to_midi + midi_to_note + note_to_hz + + + Examples + -------- + Get a single note name for a frequency + + >>> librosa.hz_to_note(440.0) + ['A5'] + + Get multiple notes with cent deviation + + >>> librosa.hz_to_note([32, 64], cents=True) + ['C1-38', 'C2-38'] + + Get multiple notes, but suppress octave labels + + >>> librosa.hz_to_note(440.0 * (2.0 ** np.linspace(0, 1, 12)), + ... octave=False) + ['A', 'A#', 'B', 'C', 'C#', 'D', 'E', 'F', 'F#', 'G', 'G#', 'A'] + + ''' + return midi_to_note(hz_to_midi(frequencies), **kwargs) + + +def hz_to_mel(frequencies, htk=False): + """Convert Hz to Mels + + Examples + -------- + >>> librosa.hz_to_mel(60) + array([ 0.9]) + >>> librosa.hz_to_mel([110, 220, 440]) + array([ 1.65, 3.3 , 6.6 ]) + + Parameters + ---------- + frequencies : np.ndarray [shape=(n,)] , float + scalar or array of frequencies + htk : bool + use HTK formula instead of Slaney + + Returns + ------- + mels : np.ndarray [shape=(n,)] + input frequencies in Mels + + See Also + -------- + mel_to_hz + """ + + frequencies = np.atleast_1d(frequencies) + + if htk: + return 2595.0 * np.log10(1.0 + frequencies / 700.0) + + # Fill in the linear part + f_min = 0.0 + f_sp = 200.0 / 3 + + mels = (frequencies - f_min) / f_sp + + # Fill in the log-scale part + + min_log_hz = 1000.0 # beginning of log region (Hz) + min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels) + logstep = np.log(6.4) / 27.0 # step size for log region + + log_t = (frequencies >= min_log_hz) + mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep + + return mels + + +def mel_to_hz(mels, htk=False): + """Convert mel bin numbers to frequencies + + Examples + -------- + >>> librosa.mel_to_hz(3) + array([ 200.]) + + >>> librosa.mel_to_hz([1,2,3,4,5]) + array([ 66.667, 133.333, 200. , 266.667, 333.333]) + + Parameters + ---------- + mels : np.ndarray [shape=(n,)], float + mel bins to convert + htk : bool + use HTK formula instead of Slaney + + Returns + ------- + frequencies : np.ndarray [shape=(n,)] + input mels in Hz + + See Also + -------- + hz_to_mel + """ + + mels = np.atleast_1d(mels) + + if htk: + return 700.0 * (10.0**(mels / 2595.0) - 1.0) + + # Fill in the linear scale + f_min = 0.0 + f_sp = 200.0 / 3 + freqs = f_min + f_sp * mels + + # And now the nonlinear scale + min_log_hz = 1000.0 # beginning of log region (Hz) + min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels) + logstep = np.log(6.4) / 27.0 # step size for log region + log_t = (mels >= min_log_mel) + + freqs[log_t] = min_log_hz * np.exp(logstep * (mels[log_t] - min_log_mel)) + + return freqs + + +def hz_to_octs(frequencies, A440=440.0): + """Convert frequencies (Hz) to (fractional) octave numbers. + + Examples + -------- + >>> librosa.hz_to_octs(440.0) + array([ 4.]) + >>> librosa.hz_to_octs([32, 64, 128, 256]) + array([ 0.219, 1.219, 2.219, 3.219]) + + Parameters + ---------- + frequencies : np.ndarray [shape=(n,)] or float + scalar or vector of frequencies + A440 : float + frequency of A440 (in Hz) + + Returns + ------- + octaves : np.ndarray [shape=(n,)] + octave number for each frequency + + See Also + -------- + octs_to_hz + """ + return np.log2(np.atleast_1d(frequencies) / (float(A440) / 16)) + + +def octs_to_hz(octs, A440=440.0): + """Convert octaves numbers to frequencies. + + Octaves are counted relative to A. + + Examples + -------- + >>> librosa.octs_to_hz(1) + array([ 55.]) + >>> librosa.octs_to_hz([-2, -1, 0, 1, 2]) + array([ 6.875, 13.75 , 27.5 , 55. , 110. ]) + + Parameters + ---------- + octaves : np.ndarray [shape=(n,)] or float + octave number for each frequency + A440 : float + frequency of A440 + + Returns + ------- + frequencies : np.ndarray [shape=(n,)] + scalar or vector of frequencies + + See Also + -------- + hz_to_octs + """ + return (float(A440) / 16)*(2.0**np.atleast_1d(octs)) + + +def fft_frequencies(sr=22050, n_fft=2048): + '''Alternative implementation of `np.fft.fftfreqs` + + Parameters + ---------- + sr : number > 0 [scalar] + Audio sampling rate + + n_fft : int > 0 [scalar] + FFT window size + + + Returns + ------- + freqs : np.ndarray [shape=(1 + n_fft/2,)] + Frequencies `(0, sr/n_fft, 2*sr/n_fft, ..., sr/2)` + + + Examples + -------- + >>> librosa.fft_frequencies(sr=22050, n_fft=16) + array([ 0. , 1378.125, 2756.25 , 4134.375, + 5512.5 , 6890.625, 8268.75 , 9646.875, 11025. ]) + + ''' + + return np.linspace(0, + float(sr) / 2, + int(1 + n_fft//2), + endpoint=True) + + +def cqt_frequencies(n_bins, fmin, bins_per_octave=12, tuning=0.0): + """Compute the center frequencies of Constant-Q bins. + + Examples + -------- + >>> # Get the CQT frequencies for 24 notes, starting at C2 + >>> librosa.cqt_frequencies(24, fmin=librosa.note_to_hz('C2')) + array([ 65.406, 69.296, 73.416, 77.782, 82.407, 87.307, + 92.499, 97.999, 103.826, 110. , 116.541, 123.471, + 130.813, 138.591, 146.832, 155.563, 164.814, 174.614, + 184.997, 195.998, 207.652, 220. , 233.082, 246.942]) + + Parameters + ---------- + n_bins : int > 0 [scalar] + Number of constant-Q bins + + fmin : float > 0 [scalar] + Minimum frequency + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : float in `[-0.5, +0.5)` + Deviation from A440 tuning in fractional bins (cents) + + Returns + ------- + frequencies : np.ndarray [shape=(n_bins,)] + Center frequency for each CQT bin + """ + + correction = 2.0**(float(tuning) / bins_per_octave) + frequencies = 2.0**(np.arange(0, n_bins, dtype=float) / bins_per_octave) + + return correction * fmin * frequencies + + +def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False): + """Compute the center frequencies of mel bands. + + Parameters + ---------- + n_mels : int > 0 [scalar] + number of Mel bins + + fmin : float >= 0 [scalar] + minimum frequency (Hz) + + fmax : float >= 0 [scalar] + maximum frequency (Hz) + + htk : bool + use HTK formula instead of Slaney + + Returns + ------- + bin_frequencies : ndarray [shape=(n_mels,)] + vector of n_mels frequencies in Hz which are uniformly spaced on the Mel + axis. + + Examples + -------- + >>> librosa.mel_frequencies(n_mels=40) + array([ 0. , 85.317, 170.635, 255.952, + 341.269, 426.586, 511.904, 597.221, + 682.538, 767.855, 853.173, 938.49 , + 1024.856, 1119.114, 1222.042, 1334.436, + 1457.167, 1591.187, 1737.532, 1897.337, + 2071.84 , 2262.393, 2470.47 , 2697.686, + 2945.799, 3216.731, 3512.582, 3835.643, + 4188.417, 4573.636, 4994.285, 5453.621, + 5955.205, 6502.92 , 7101.009, 7754.107, + 8467.272, 9246.028, 10096.408, 11025. ]) + + """ + + # 'Center freqs' of mel bands - uniformly spaced between limits + min_mel = hz_to_mel(fmin, htk=htk) + max_mel = hz_to_mel(fmax, htk=htk) + + mels = np.linspace(min_mel, max_mel, n_mels) + + return mel_to_hz(mels, htk=htk) + + +# A-weighting should be capitalized: suppress the naming warning +def A_weighting(frequencies, min_db=-80.0): # pylint: disable=invalid-name + '''Compute the A-weighting of a set of frequencies. + + Parameters + ---------- + frequencies : scalar or np.ndarray [shape=(n,)] + One or more frequencies (in Hz) + + min_db : float [scalar] or None + Clip weights below this threshold. + If `None`, no clipping is performed. + + Returns + ------- + A_weighting : scalar or np.ndarray [shape=(n,)] + `A_weighting[i]` is the A-weighting of `frequencies[i]` + + See Also + -------- + perceptual_weighting + + + Examples + -------- + + Get the A-weighting for CQT frequencies + + >>> import matplotlib.pyplot as plt + >>> freqs = librosa.cqt_frequencies(108, librosa.note_to_hz('C1')) + >>> aw = librosa.A_weighting(freqs) + >>> plt.plot(freqs, aw) + >>> plt.xlabel('Frequency (Hz)') + >>> plt.ylabel('Weighting (log10)') + >>> plt.title('A-Weighting of CQT frequencies') + + ''' + + # Vectorize to make our lives easier + frequencies = np.atleast_1d(frequencies) + + # Pre-compute squared frequency + f_sq = frequencies**2.0 + + const = np.array([12200, 20.6, 107.7, 737.9])**2.0 + + weights = 2.0 + 20.0 * (np.log10(const[0]) + 4 * np.log10(frequencies) + - np.log10(f_sq + const[0]) + - np.log10(f_sq + const[1]) + - 0.5 * np.log10(f_sq + const[2]) + - 0.5 * np.log10(f_sq + const[3])) + + if min_db is not None: + weights = np.maximum(min_db, weights) + + return weights diff --git a/librosa/decompose.py b/librosa/decompose.py new file mode 100644 index 0000000000..421674d737 --- /dev/null +++ b/librosa/decompose.py @@ -0,0 +1,328 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Spectrogram decomposition +========================= +.. autosummary:: + :toctree: generated/ + + decompose + hpss +""" + +import numpy as np + +from scipy.ndimage import median_filter + +import sklearn.decomposition + +from . import core +from . import cache +from . import util +from .util.exceptions import ParameterError + +__all__ = ['decompose', 'hpss'] + + +def decompose(S, n_components=None, transformer=None, sort=False, fit=True, **kwargs): + """Decompose a feature matrix. + + Given a spectrogram `S`, produce a decomposition into `components` + and `activations` such that `S ~= components.dot(activations)`. + + By default, this is done with with non-negative matrix factorization (NMF), + but any `sklearn.decomposition`-type object will work. + + + Parameters + ---------- + S : np.ndarray [shape=(n_features, n_samples), dtype=float] + The input feature matrix (e.g., magnitude spectrogram) + + n_components : int > 0 [scalar] or None + number of desired components + + if None, then `n_features` components are used + + transformer : None or object + If None, use `sklearn.decomposition.NMF` + + Otherwise, any object with a similar interface to NMF should work. + `transformer` must follow the scikit-learn convention, where + input data is `(n_samples, n_features)`. + + `transformer.fit_transform()` will be run on `S.T` (not `S`), + the return value of which is stored (transposed) as `activations` + + The components will be retrieved as `transformer.components_.T` + + `S ~= np.dot(activations, transformer.components_).T` + + or equivalently: + `S ~= np.dot(transformer.components_.T, activations.T)` + + sort : bool + If `True`, components are sorted by ascending peak frequency. + + .. note:: If used with `transformer`, sorting is applied to copies + of the decomposition parameters, and not to `transformer`'s + internal parameters. + + fit : bool + If `True`, components are estimated from the input ``S``. + + If `False`, components are assumed to be pre-computed and stored + in ``transformer``, and are not changed. + + kwargs : Additional keyword arguments to the default transformer + `sklearn.decomposition.NMF` + + + Returns + ------- + components: np.ndarray [shape=(n_features, n_components)] + matrix of components (basis elements). + + activations: np.ndarray [shape=(n_components, n_samples)] + transformed matrix/activation matrix + + + Raises + ------ + ParameterError + if `fit` is False and no `transformer` object is provided. + + + See Also + -------- + sklearn.decomposition : SciKit-Learn matrix decomposition modules + + + Examples + -------- + Decompose a magnitude spectrogram into 32 components with NMF + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + >>> comps, acts = librosa.decompose.decompose(S, n_components=8) + >>> comps + array([[ 1.876e-01, 5.559e-02, ..., 1.687e-01, 4.907e-02], + [ 3.148e-01, 1.719e-01, ..., 2.314e-01, 9.493e-02], + ..., + [ 1.561e-07, 8.564e-08, ..., 7.167e-08, 4.997e-08], + [ 1.531e-07, 7.880e-08, ..., 5.632e-08, 4.028e-08]]) + >>> acts + array([[ 4.197e-05, 8.512e-03, ..., 3.056e-05, 9.159e-06], + [ 9.568e-06, 1.718e-02, ..., 3.322e-05, 7.869e-06], + ..., + [ 5.982e-05, 1.311e-02, ..., -0.000e+00, 6.323e-06], + [ 3.782e-05, 7.056e-03, ..., 3.290e-05, -0.000e+00]]) + + + Sort components by ascending peak frequency + + >>> comps, acts = librosa.decompose.decompose(S, n_components=8, + ... sort=True) + + + Or with sparse dictionary learning + + >>> import sklearn.decomposition + >>> T = sklearn.decomposition.MiniBatchDictionaryLearning(n_components=8) + >>> comps, acts = librosa.decompose.decompose(S, transformer=T, sort=True) + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(10,8)) + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(S**2, + ... ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('Input spectrogram') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.subplot(3, 2, 3) + >>> librosa.display.specshow(comps, y_axis='log') + >>> plt.title('Components') + >>> plt.subplot(3, 2, 4) + >>> librosa.display.specshow(acts, x_axis='time') + >>> plt.ylabel('Components') + >>> plt.title('Activations') + >>> plt.subplot(3, 1, 3) + >>> S_approx = comps.dot(acts) + >>> librosa.display.specshow(librosa.logamplitude(S_approx**2, + ... ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Reconstructed spectrogram') + >>> plt.tight_layout() + """ + + if transformer is None: + if fit is False: + raise ParameterError('fit must be True if transformer is None') + + transformer = sklearn.decomposition.NMF(n_components=n_components, + **kwargs) + + if n_components is None: + n_components = S.shape[0] + + if fit: + activations = transformer.fit_transform(S.T).T + else: + activations = transformer.transform(S.T).T + + components = transformer.components_.T + + if sort: + components, idx = util.axis_sort(components, index=True) + activations = activations[idx] + + return components, activations + + +@cache +def hpss(S, kernel_size=31, power=2.0, mask=False): + """Median-filtering harmonic percussive source separation (HPSS). + + Decomposes an input spectrogram `S = H + P` + where `H` contains the harmonic components, + and `P` contains the percussive components. + + This implementation is based upon the algorithm described by [1]_. + + .. [1] Fitzgerald, Derry. + "Harmonic/percussive separation using median filtering." + 13th International Conference on Digital Audio Effects (DAFX10), + Graz, Austria, 2010. + + + Parameters + ---------- + S : np.ndarray [shape=(d, n)] + input spectrogram. May be real (magnitude) or complex. + + kernel_size : int or tuple (kernel_harmonic, kernel_percussive) + kernel size(s) for the median filters. + + - If scalar, the same size is used for both harmonic and percussive. + - If iterable, the first value specifies the width of the + harmonic filter, and the second value specifies the width + of the percussive filter. + + + power : float >= 0 [scalar] + Exponent for the Wiener filter when constructing mask matrices. + + Mask matrices are defined by + `mask_H = (r_H ** power) / (r_H ** power + r_P ** power)` + where `r_H` and `r_P` are the median-filter responses for + harmonic and percussive components. + + mask : bool + Return the masking matrices instead of components + + + Returns + ------- + harmonic : np.ndarray [shape=(d, n)] + harmonic component (or mask) + + percussive : np.ndarray [shape=(d, n)] + percussive component (or mask) + + + Examples + -------- + Separate into harmonic and percussive + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15) + >>> D = librosa.stft(y) + >>> H, P = librosa.decompose.hpss(D) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(np.abs(D)**2, + ... ref_power=np.max), + ... y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Full power spectrogram') + >>> plt.subplot(3, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(np.abs(H)**2, + ... ref_power=np.max), + ... y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Harmonic power spectrogram') + >>> plt.subplot(3, 1, 3) + >>> librosa.display.specshow(librosa.logamplitude(np.abs(P)**2, + ... ref_power=np.max), + ... y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Percussive power spectrogram') + >>> plt.tight_layout() + + + Or with a narrower horizontal filter + + >>> H, P = librosa.decompose.hpss(D, kernel_size=(13, 31)) + + Just get harmonic/percussive masks, not the spectra + + >>> mask_H, mask_P = librosa.decompose.hpss(D, mask=True) + >>> mask_H + array([[ 1., 0., ..., 0., 0.], + [ 1., 0., ..., 0., 0.], + ..., + [ 0., 0., ..., 0., 0.], + [ 0., 0., ..., 0., 0.]]) + >>> mask_P + array([[ 0., 1., ..., 1., 1.], + [ 0., 1., ..., 1., 1.], + ..., + [ 1., 1., ..., 1., 1.], + [ 1., 1., ..., 1., 1.]]) + + """ + + if np.iscomplexobj(S): + S, phase = core.magphase(S) + else: + phase = 1 + + if np.isscalar(kernel_size): + win_harm = kernel_size + win_perc = kernel_size + else: + win_harm = kernel_size[0] + win_perc = kernel_size[1] + + # Compute median filters. Pre-allocation here preserves memory layout. + harm = np.empty_like(S) + harm[:] = median_filter(S, size=(1, win_harm), mode='reflect') + + perc = np.empty_like(S) + perc[:] = median_filter(S, size=(win_perc, 1), mode='reflect') + + if mask or power < util.SMALL_FLOAT: + mask_harm = (harm > perc).astype(float) + mask_perc = 1 - mask_harm + if mask: + return mask_harm, mask_perc + else: + perc = perc ** power + zero_perc = (perc < util.SMALL_FLOAT) + perc[zero_perc] = 0.0 + + harm = harm ** power + zero_harm = (harm < util.SMALL_FLOAT) + harm[zero_harm] = 0.0 + + # Find points where both are zero, equalize + harm[zero_harm & zero_perc] = 0.5 + perc[zero_harm & zero_perc] = 0.5 + + # Compute harmonic mask + mask_harm = harm / (harm + perc) + mask_perc = perc / (harm + perc) + + return ((S * mask_harm) * phase, (S * mask_perc) * phase) diff --git a/librosa/display.py b/librosa/display.py new file mode 100644 index 0000000000..d503ae8893 --- /dev/null +++ b/librosa/display.py @@ -0,0 +1,1018 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Display +======= +.. autosummary:: + :toctree: generated/ + + specshow + waveplot + time_ticks + cmap +""" + +import numpy as np +import copy +import matplotlib as mpl +import matplotlib.image as img +import matplotlib.pyplot as plt +import warnings + +from . import cache +from . import core +from . import util +from .util.exceptions import ParameterError + +_HAS_SEABORN = False +try: + _matplotlibrc = copy.deepcopy(mpl.rcParams) + import seaborn as sns + _HAS_SEABORN = True + mpl.rcParams.update(**_matplotlibrc) +except ImportError: + pass + + +# This function wraps xticks or yticks: star-args is okay +def time_ticks(locs, *args, **kwargs): # pylint: disable=star-args + '''Plot time-formatted axis ticks. + + Parameters + ---------- + locations : list or np.ndarray + Time-stamps for tick marks + + n_ticks : int > 0 or None + Show this number of ticks (evenly spaced). + + If none, all ticks are displayed. + + Default: 5 + + axis : 'x' or 'y' + Which axis should the ticks be plotted on? + Default: 'x' + + time_fmt : None or {'ms', 's', 'm', 'h'} + - 'ms': milliseconds (eg, 241ms) + - 's': seconds (eg, 1.43s) + - 'm': minutes (eg, 1:02) + - 'h': hours (eg, 1:02:03) + + If none, formatted is automatically selected by the + range of the times data. + + Default: None + + fmt : str + .. warning:: This parameter name was in librosa 0.4.2 + Use the `time_fmt` parameter instead. + The `fmt` parameter will be removed in librosa 0.5.0. + + kwargs : additional keyword arguments. + See `matplotlib.pyplot.xticks` or `yticks` for details. + + + Returns + ------- + locs + labels + Locations and labels of tick marks + + + See Also + -------- + matplotlib.pyplot.xticks + matplotlib.pyplot.yticks + + + Examples + -------- + >>> # Tick at pre-computed beat times + >>> librosa.display.specshow(S) + >>> librosa.display.time_ticks(beat_times) + + >>> # Set the locations of the time stamps + >>> librosa.display.time_ticks(locations, timestamps) + + >>> # Format in seconds + >>> librosa.display.time_ticks(beat_times, time_fmt='s') + + >>> # Tick along the y axis + >>> librosa.display.time_ticks(beat_times, axis='y') + + ''' + + n_ticks = kwargs.pop('n_ticks', 5) + axis = kwargs.pop('axis', 'x') + fmt = kwargs.pop('fmt', util.Deprecated()) + time_fmt = kwargs.pop('time_fmt', None) + + time_fmt = util.rename_kw('fmt', fmt, 'time_fmt', time_fmt, '0.4.2', '0.5.0') + + if axis == 'x': + ticker = plt.xticks + elif axis == 'y': + ticker = plt.yticks + else: + raise ParameterError("axis must be either 'x' or 'y'.") + + if len(args) > 0: + times = args[0] + else: + times = locs + locs = np.arange(len(times)) + + if n_ticks is not None: + # Slice the locations and labels evenly between 0 and the last point + positions = np.linspace(0, len(locs)-1, n_ticks, + endpoint=True).astype(int) + locs = locs[positions] + times = times[positions] + + # Format the labels by time + formats = {'ms': lambda t: '{:d}ms'.format(int(1e3 * t)), + 's': '{:0.2f}s'.format, + 'm': lambda t: '{:d}:{:02d}'.format(int(t / 6e1), + int(np.mod(t, 6e1))), + 'h': lambda t: '{:d}:{:02d}:{:02d}'.format(int(t / 3.6e3), + int(np.mod(t / 6e1, + 6e1)), + int(np.mod(t, 6e1)))} + + if time_fmt is None: + if max(times) > 3.6e3: + time_fmt = 'h' + elif max(times) > 6e1: + time_fmt = 'm' + elif max(times) > 1.0: + time_fmt = 's' + else: + time_fmt = 'ms' + + elif time_fmt not in formats: + raise ParameterError('Invalid format: {:s}'.format(time_fmt)) + + times = [formats[time_fmt](t) for t in times] + + return ticker(locs, times, **kwargs) + + +def frequency_ticks(locs, *args, **kwargs): # pylint: disable=star-args + '''Plot frequency-formatted axis ticks. + + Parameters + ---------- + locations : list or np.ndarray + Frequency values for tick marks + + n_ticks : int > 0 or None + Show this number of ticks (evenly spaced). + + If none, all ticks are displayed. + + Default: 5 + + axis : 'x' or 'y' + Which axis should the ticks be plotted on? + Default: 'x' + + freq_fmt : None or {'mHz', 'Hz', 'kHz', 'MHz', 'GHz'} + - 'mHz': millihertz + - 'Hz': hertz + - 'kHz': kilohertz + - 'MHz': megahertz + - 'GHz': gigahertz + + If none, formatted is automatically selected by the + range of the frequency data. + + Default: None + + kwargs : additional keyword arguments. + See `matplotlib.pyplot.xticks` or `yticks` for details. + + + Returns + ------- + (locs, labels) + Locations and labels of tick marks + + label + Axis label + + See Also + -------- + matplotlib.pyplot.xticks + matplotlib.pyplot.yticks + + + Examples + -------- + >>> # Tick at pre-computed beat times + >>> librosa.display.specshow(S) + >>> librosa.display.frequency_ticks() + + >>> # Set the locations of the time stamps + >>> librosa.display.frequency_ticks(locations, frequencies) + + >>> # Format in hertz + >>> librosa.display.frequency_ticks(frequencies, freq_fmt='Hz') + + >>> # Tick along the y axis + >>> librosa.display.frequency_ticks(frequencies, axis='y') + + ''' + + n_ticks = kwargs.pop('n_ticks', 5) + axis = kwargs.pop('axis', 'x') + freq_fmt = kwargs.pop('freq_fmt', None) + + if axis == 'x': + ticker = plt.xticks + elif axis == 'y': + ticker = plt.yticks + else: + raise ParameterError("axis must be either 'x' or 'y'.") + + if len(args) > 0: + freqs = args[0] + else: + freqs = locs + locs = np.arange(len(freqs)) + + if n_ticks is not None: + # Slice the locations and labels evenly between 0 and the last point + positions = np.linspace(0, len(locs)-1, n_ticks, + endpoint=True).astype(int) + locs = locs[positions] + freqs = freqs[positions] + + # Format the labels by time + formats = {'mHz': lambda f: '{:.5g}'.format(f * 1e3), + 'Hz': '{:.5g}'.format, + 'kHz': lambda f: '{:.5g}'.format(f * 1e-3), + 'MHz': lambda f: '{:.5g}'.format(f * 1e-6), + 'GHz': lambda f: '{:.5g}'.format(f * 1e-9)} + + f_max = np.max(freqs) + + if freq_fmt is None: + if f_max > 1e10: + freq_fmt = 'GHz' + elif f_max > 1e7: + freq_fmt = 'MHz' + elif f_max > 1e4: + freq_fmt = 'kHz' + elif f_max > 1e1: + freq_fmt = 'Hz' + else: + freq_fmt = 'mHz' + + elif freq_fmt not in formats: + raise ParameterError('Invalid format: {:s}'.format(freq_fmt)) + + ticks = [formats[freq_fmt](f) for f in freqs] + + return ticker(locs, ticks, **kwargs), freq_fmt + + +@cache +def cmap(data, use_sns=True, robust=True): + '''Get a default colormap from the given data. + + If the data is boolean, use a black and white colormap. + + If the data has both positive and negative values, + use a diverging colormap ('coolwarm'). + + Otherwise, use a sequential map: either cubehelix or 'OrRd'. + + Parameters + ---------- + data : np.ndarray + Input data + + use_sns : bool + If True, and `seaborn` is installed, use cubehelix maps for + sequential data + + robust : bool + If True, discard the top and bottom 2% of data when calculating + range. + + Returns + ------- + cmap : matplotlib.colors.Colormap + - If `data` has dtype=boolean, `cmap` is 'gray_r' + - If `data` has only positive or only negative values, + `cmap` is 'OrRd' (`use_sns==False`) or cubehelix + - If `data` has both positive and negatives, `cmap` is 'coolwarm' + + See Also + -------- + matplotlib.pyplot.colormaps + seaborn.cubehelix_palette + ''' + + data = np.atleast_1d(data) + + if data.dtype == 'bool': + return plt.get_cmap('gray_r') + + data = data[np.isfinite(data)] + + if robust: + min_p, max_p = 2, 98 + else: + min_p, max_p = 0, 100 + + max_val = np.percentile(data, max_p) + min_val = np.percentile(data, min_p) + + if min_val >= 0 or max_val <= 0: + if use_sns and _HAS_SEABORN: + return sns.cubehelix_palette(light=1.0, as_cmap=True) + else: + return plt.get_cmap('OrRd') + + return plt.get_cmap('coolwarm') + + +def __envelope(x, hop): + '''Compute the max-envelope of x at a stride/frame length of h''' + return util.frame(x, hop_length=hop, frame_length=hop).max(axis=0) + + +def waveplot(y, sr=22050, max_points=5e4, x_axis='time', offset=0.0, max_sr=1000, + time_fmt=None, **kwargs): + '''Plot the amplitude envelope of a waveform. + + If `y` is monophonic, a filled curve is drawn between `[-abs(y), abs(y)]`. + + If `y` is stereo, the curve is drawn between `[-abs(y[1]), abs(y[0])]`, + so that the left and right channels are drawn above and below the axis, + respectively. + + Long signals (`duration >= max_points`) are down-sampled to at + most `max_sr` before plotting. + + Parameters + ---------- + y : np.ndarray [shape=(n,) or (2,n)] + audio time series (mono or stereo) + + sr : number > 0 [scalar] + sampling rate of `y` + + max_points : postive number or None + Maximum number of time-points to plot: if `max_points` exceeds + the duration of `y`, then `y` is downsampled. + + If `None`, no downsampling is performed. + + x_axis : str {'time', 'off', 'none'} or None + If 'time', the x-axis is given time tick-marks. + + See also: `time_ticks` + + offset : float + Horizontal offset (in time) to start the waveform plot + + max_sr : number > 0 [scalar] + Maximum sampling rate for the visualization + + time_fmt : None or str + Formatting for time axis. None (automatic) by default. + + See `time_ticks`. + + kwargs + Additional keyword arguments to `matplotlib.pyplot.fill_between` + + Returns + ------- + pc : matplotlib.collections.PolyCollection + The PolyCollection created by `fill_between`. + + See also + -------- + time_ticks + librosa.core.resample + matplotlib.pyplot.fill_between + + + Examples + -------- + Plot a monophonic waveform + + >>> import matplotlib.pyplot as plt + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=10) + >>> plt.figure() + >>> plt.subplot(3, 1, 1) + >>> librosa.display.waveplot(y, sr=sr) + >>> plt.title('Monophonic') + + Or a stereo waveform + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... mono=False, duration=10) + >>> plt.subplot(3, 1, 2) + >>> librosa.display.waveplot(y, sr=sr) + >>> plt.title('Stereo') + + Or harmonic and percussive components with transparency + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=10) + >>> y_harm, y_perc = librosa.effects.hpss(y) + >>> plt.subplot(3, 1, 3) + >>> librosa.display.waveplot(y_harm, sr=sr, alpha=0.25) + >>> librosa.display.waveplot(y_perc, sr=sr, color='r', alpha=0.5) + >>> plt.title('Harmonic + Percussive') + >>> plt.tight_layout() + ''' + + util.valid_audio(y, mono=False) + + if not (isinstance(max_sr, int) and max_sr > 0): + raise ParameterError('max_sr must be a non-negative integer') + + target_sr = sr + + if max_points is not None: + if max_points <= 0: + raise ParameterError('max_points must be strictly positive') + + if max_points < y.shape[-1]: + target_sr = min(max_sr, (sr * y.shape[-1]) // max_points) + + hop_length = sr // target_sr + + if y.ndim == 1: + y = __envelope(y, hop_length) + else: + y = np.vstack([__envelope(_, hop_length) for _ in y]) + + if y.ndim > 1: + y_top = y[0] + y_bottom = -y[1] + else: + y_top = y + y_bottom = -y + + axes = plt.gca() + + if hasattr(axes._get_lines, 'prop_cycler'): + # matplotlib >= 1.5 + kwargs.setdefault('color', next(axes._get_lines.prop_cycler)['color']) + else: + # matplotlib 1.4 + kwargs.setdefault('color', next(axes._get_lines.color_cycle)) + + sample_off = core.time_to_samples(offset, sr=target_sr) + + locs = np.arange(sample_off, sample_off + len(y_top)) + out = axes.fill_between(locs, y_bottom, y_top, **kwargs) + + plt.xlim([locs[0], locs[-1]]) + + if x_axis == 'time': + time_ticks(locs, core.samples_to_time(locs, sr=target_sr), time_fmt=time_fmt) + elif x_axis is None or x_axis in ['off', 'none']: + plt.xticks([]) + else: + raise ParameterError('Unknown x_axis value: {}'.format(x_axis)) + + return out + + +def specshow(data, sr=22050, hop_length=512, x_axis=None, y_axis=None, + n_xticks=5, n_yticks=5, fmin=None, fmax=None, bins_per_octave=12, + tmin=16, tmax=240, freq_fmt='Hz', time_fmt=None, **kwargs): + '''Display a spectrogram/chromagram/cqt/etc. + + Functions as a drop-in replacement for `matplotlib.pyplot.imshow`, + but with useful defaults. + + + Parameters + ---------- + data : np.ndarray [shape=(d, n)] + Matrix to display (e.g., spectrogram) + + sr : number > 0 [scalar] + Sample rate used to determine time scale in x-axis. + + hop_length : int > 0 [scalar] + Hop length, also used to determine time scale in x-axis + + x_axis : None or str + + y_axis : None or str + Range for the x- and y-axes. + + Valid types are: + + - None or 'off' : no axis is displayed. + + Frequency types: + + - 'linear' : frequency range is determined by the FFT window + and sampling rate. + - 'log' : the image is displayed on a vertical log scale. + - 'mel' : frequencies are determined by the mel scale. + - 'cqt_hz' : frequencies are determined by the CQT scale. + - 'cqt_note' : pitches are determined by the CQT scale. + - 'chroma' : pitches are determined by the chroma filters. + - 'tonnetz' : axes are labeled by Tonnetz dimensions + + Time types: + + - 'time' : markers are shown as milliseconds, seconds, + minutes, or hours + - 'lag' : like time, but past the half-way point counts + as negative values. + - 'frames' : markers are shown as frame counts. + - 'tempo' : markers are shown as beats-per-minute + + n_xticks : int > 0 [scalar] + If x_axis is drawn, the number of ticks to show + + n_yticks : int > 0 [scalar] + If y_axis is drawn, the number of ticks to show + + fmin : float > 0 [scalar] or None + Frequency of the lowest spectrogram bin. Used for Mel and CQT + scales. + + If `y_axis` is `cqt_hz` or `cqt_note` and `fmin` is not given, + it is set by default to `note_to_hz('C1')`. + + fmax : float > 0 [scalar] or None + Used for setting the Mel frequency scales + + bins_per_octave : int > 0 [scalar] + Number of bins per octave. Used for CQT frequency scale. + + tmin : float > 0 [scalar] + tmax : float > 0 [scalar] + Minimum and maximum tempi displayed when `_axis='tempo'`, + as measured in beats per minute. + + freq_fmt : None or str + Formatting for frequency axes. 'Hz', by default. + + See `frequency_ticks`. + + time_fmt : None or str + Formatting for time axes. None (automatic) by default. + + See `time_ticks`. + + kwargs : additional keyword arguments + Arguments passed through to `matplotlib.pyplot.imshow`. + + + Returns + ------- + image : `matplotlib.image.AxesImage` + As returned from `matplotlib.pyplot.imshow`. + + + See Also + -------- + cmap : Automatic colormap detection + + time_ticks : time-formatted tick marks + + frequency_ticks : frequency-formatted tick marks + + matplotlib.pyplot.imshow + + + Examples + -------- + Visualize an STFT power spectrum + + >>> import matplotlib.pyplot as plt + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> plt.figure(figsize=(12, 8)) + + >>> D = librosa.logamplitude(np.abs(librosa.stft(y))**2, ref_power=np.max) + >>> plt.subplot(4, 2, 1) + >>> librosa.display.specshow(D, y_axis='linear') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Linear-frequency power spectrogram') + + + Or on a logarithmic scale + + >>> plt.subplot(4, 2, 2) + >>> librosa.display.specshow(D, y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Log-frequency power spectrogram') + + + Or use a CQT scale + + >>> CQT = librosa.logamplitude(librosa.cqt(y, sr=sr)**2, ref_power=np.max) + >>> plt.subplot(4, 2, 3) + >>> librosa.display.specshow(CQT, y_axis='cqt_note') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Constant-Q power spectrogram (note)') + + >>> plt.subplot(4, 2, 4) + >>> librosa.display.specshow(CQT, y_axis='cqt_hz') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Constant-Q power spectrogram (Hz)') + + + Draw a chromagram with pitch classes + + >>> C = librosa.feature.chroma_cqt(y=y, sr=sr) + >>> plt.subplot(4, 2, 5) + >>> librosa.display.specshow(C, y_axis='chroma') + >>> plt.colorbar() + >>> plt.title('Chromagram') + + + Force a grayscale colormap (white -> black) + + >>> plt.subplot(4, 2, 6) + >>> librosa.display.specshow(D, cmap='gray_r', y_axis='linear') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Linear power spectrogram (grayscale)') + + + Draw time markers automatically + + >>> plt.subplot(4, 2, 7) + >>> librosa.display.specshow(D, x_axis='time', y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Log power spectrogram') + + + Draw a tempogram with BPM markers + + >>> plt.subplot(4, 2, 8) + >>> oenv = librosa.onset.onset_strength(y=y, sr=sr) + >>> tempo = librosa.beat.estimate_tempo(oenv, sr=sr) + >>> Tgram = librosa.feature.tempogram(y=y, sr=sr) + >>> librosa.display.specshow(Tgram[:100], x_axis='time', y_axis='tempo', + ... tmin=tempo/4, tmax=tempo*2, n_yticks=4) + >>> plt.colorbar() + >>> plt.title('Tempogram') + >>> plt.tight_layout() + + + ''' + + kwargs.setdefault('aspect', 'auto') + kwargs.setdefault('origin', 'lower') + kwargs.setdefault('interpolation', 'nearest') + + if np.issubdtype(data.dtype, np.complex): + warnings.warn('Trying to display complex-valued input. ' + 'Showing magnitude instead.') + data = np.abs(data) + + kwargs.setdefault('cmap', cmap(data)) + + axes = plt.imshow(data, **kwargs) + + all_params = dict(kwargs=kwargs, + sr=sr, + fmin=fmin, + fmax=fmax, + bins_per_octave=bins_per_octave, + tmin=tmin, + tmax=tmax, + hop_length=hop_length, + time_fmt=time_fmt, + freq_fmt=freq_fmt) + + # Scale and decorate the axes + __axis(data, n_xticks, x_axis, horiz=True, minor=y_axis, **all_params) + __axis(data, n_yticks, y_axis, horiz=False, minor=x_axis, **all_params) + + return axes + + +def __get_shape_artists(data, horiz): + '''Return size, ticker, and labeler''' + if horiz: + return data.shape[1], plt.xticks, plt.xlabel + else: + return data.shape[0], plt.yticks, plt.ylabel + + +def __axis(data, n_ticks, ax_type, horiz=False, **kwargs): + '''Dispatch function to decorate axes''' + axis_map = {'linear': __axis_linear, + 'log': __axis_log, + 'mel': __axis_mel, + 'cqt_hz': __axis_cqt_hz, + 'cqt_note': __axis_cqt_note, + 'chroma': __axis_chroma, + 'tonnetz': __axis_tonnetz, + 'off': __axis_none, + 'time': __axis_time, + 'tempo': __axis_tempo, + 'lag': __axis_lag, + 'frames': __axis_frames} + + if ax_type is None: + ax_type = 'off' + + if ax_type not in axis_map: + raise ParameterError('Unknown axis type: {:s}'.format(ax_type)) + + func = axis_map[ax_type] + + func(data, n_ticks, horiz=horiz, **kwargs) + + +def __axis_none(data, n_ticks, horiz, **_kwargs): + '''Empty axis artist''' + + _, ticker, labeler = __get_shape_artists(data, horiz) + + ticker([]) + labeler('') + + +def __axis_log(data, n_ticks, horiz, sr=22050, kwargs=None, + secondary_axis='linear', minor=None, **_kwargs): + '''Plot a log-scaled image''' + + axes_phantom = plt.gca() + + if kwargs is None: + kwargs = dict() + + aspect = kwargs.pop('aspect', None) + fmt = _kwargs.pop('freq_fmt', 'Hz') + + n, ticker, labeler = __get_shape_artists(data, horiz) + t_log, t_inv = __log_scale(n) + + if horiz: + axis = 'x' + + if minor == 'log': + ax2 = __log_scale(data.shape[0])[0] + else: + ax2 = np.arange(data.shape[0]) + ax1 = t_log + else: + axis = 'y' + if minor == 'log': + ax1 = __log_scale(data.shape[1])[0] + else: + ax1 = np.arange(data.shape[1]) + + ax2 = t_log + + args = (ax1, ax2, data) + + # NOTE: 2013-11-14 16:15:33 by Brian McFee + # We draw the image twice here. This is a hack to get around + # NonUniformImage not properly setting hooks for color. + # Drawing twice enables things like colorbar() to work properly. + + im_phantom = img.NonUniformImage(axes_phantom, + extent=(args[0].min(), args[0].max(), + args[1].min(), args[1].max()), + **kwargs) + im_phantom.set_data(*args) + + kwargs['aspect'] = aspect + + axes_phantom.images[0] = im_phantom + + positions = np.linspace(0, n-1, n_ticks, endpoint=True).astype(int) + # One extra value here to catch nyquist + values = np.linspace(0, 0.5 * sr, n, endpoint=True) + + _, label = frequency_ticks(positions, values[t_inv[positions]], + n_ticks=None, axis=axis, freq_fmt=fmt) + labeler(label) + + +def __axis_mel(data, n_ticks, horiz, fmin=None, fmax=None, **_kwargs): + '''Mel-scaled axes''' + + fmt = _kwargs.pop('freq_fmt', 'Hz') + + if horiz: + axis = 'x' + else: + axis = 'y' + + n, ticker, labeler = __get_shape_artists(data, horiz) + + positions = np.linspace(0, n-1, n_ticks).astype(int) + + kwargs = {} + + if fmin is not None: + kwargs['fmin'] = fmin + + if fmax is not None: + kwargs['fmax'] = fmax + + # only two star-args here, defined immediately above + # pylint: disable=star-args + values = core.mel_frequencies(n_mels=n+2, **kwargs)[positions] + _, label = frequency_ticks(positions, values, + n_ticks=None, axis=axis, freq_fmt=fmt) + labeler(label) + + +def __axis_chroma(data, n_ticks, horiz, bins_per_octave=12, **_kwargs): + '''Chroma axes''' + + n, ticker, labeler = __get_shape_artists(data, horiz) + + # Generate the template positions: C D E F G A B + pos = np.asarray([0, 2, 4, 5, 7, 9, 11]) * bins_per_octave // 12 + + n_octaves = np.ceil(n / float(bins_per_octave)) + + positions = pos.copy() + for i in range(1, int(n_octaves)): + positions = np.append(positions, pos + i * bins_per_octave, axis=0) + + values = core.midi_to_note(positions * 12 // bins_per_octave, octave=False) + ticker(positions[:n], values[:n]) + labeler('Pitch class') + + +def __axis_linear(data, n_ticks, horiz, sr=22050, **_kwargs): + '''Linear frequency axes''' + fmt = _kwargs.pop('freq_fmt', 'Hz') + + if horiz: + axis = 'x' + else: + axis = 'y' + + n, ticker, labeler = __get_shape_artists(data, horiz) + + positions = np.linspace(0, n - 1, n_ticks, endpoint=True).astype(int) + values = (sr * np.linspace(0, 0.5, n_ticks, endpoint=True)) + + _, label = frequency_ticks(positions, values, + n_ticks=None, axis=axis, freq_fmt=fmt) + labeler(label) + + +def __axis_cqt(data, n_ticks, horiz, note=False, fmin=None, + bins_per_octave=12, **_kwargs): + '''CQT axes''' + if fmin is None: + fmin = core.note_to_hz('C1') + + if horiz: + axis = 'x' + else: + axis = 'y' + + fmt = _kwargs.pop('freq_fmt', 'Hz') + + n, ticker, labeler = __get_shape_artists(data, horiz) + + positions = np.linspace(0, n-1, num=n_ticks, endpoint=True).astype(int) + + values = core.cqt_frequencies(n + 1, + fmin=fmin, + bins_per_octave=bins_per_octave) + + if note: + values = core.hz_to_note(values[positions]) + label = 'Note' + ticker(positions, values) + else: + values = values[positions] + _, label = frequency_ticks(positions, values, + n_ticks=None, axis=axis, freq_fmt=fmt) + + labeler(label) + + +def __axis_cqt_hz(*args, **kwargs): + '''CQT in Hz''' + kwargs['note'] = False + __axis_cqt(*args, **kwargs) + + +def __axis_cqt_note(*args, **kwargs): + '''CQT in notes''' + kwargs['note'] = True + __axis_cqt(*args, **kwargs) + + +def __axis_time(data, n_ticks, horiz, sr=22050, hop_length=512, **_kwargs): + '''Time axes''' + n, ticker, labeler = __get_shape_artists(data, horiz) + + if horiz: + axis = 'x' + else: + axis = 'y' + + fmt = _kwargs.pop('time_fmt', None) + + positions = np.linspace(0, n-1, n_ticks, endpoint=True).astype(int) + + time_ticks(positions, + core.frames_to_time(positions, sr=sr, hop_length=hop_length), + n_ticks=None, time_fmt=fmt, axis=axis) + + labeler('Time') + + +def __axis_tempo(data, n_ticks, horiz, sr=22050, hop_length=512, tmin=16, tmax=240, **_kwargs): + '''Tempo axes''' + n, ticker, labeler = __get_shape_artists(data, horiz) + + nmin = min(n-1, sr * 60.0 / (hop_length * tmin)) + nmax = max(1, sr * 60.0 / (hop_length * tmax)) + + positions = np.logspace(np.log2(nmin), np.log2(nmax), + num=n_ticks, endpoint=True, base=2).astype(int) + + tempi = ['{:.1f}'.format(60 * float(sr) / (hop_length * t)) for t in positions] + ticker(positions, tempi) + labeler('Tempo (BPM)') + + + +def __axis_lag(data, n_ticks, horiz, sr=22050, hop_length=512, **_kwargs): + '''Lag axes''' + n, ticker, labeler = __get_shape_artists(data, horiz) + + if horiz: + axis = 'x' + else: + axis = 'y' + + positions = np.linspace(0, n-1, n_ticks, endpoint=True).astype(int) + times = core.frames_to_time(positions, sr=sr, hop_length=hop_length) + times[positions >= n//2] -= times[-1] + + time_ticks(positions, times, n_ticks=None, axis=axis) + + labeler('Lag') + + +def __axis_tonnetz(data, n_ticks, horiz, **_kwargs): + '''Chroma axes''' + + n, ticker, labeler = __get_shape_artists(data, horiz) + + positions = np.arange(6) + + values = [r'5$_x$', r'5$_y$', + r'm3$_x$', r'm3$_y$', + r'M3$_x$', r'M3$_y$'] + + ticker(positions, values) + labeler('Tonnetz') + + +def __axis_frames(data, n_ticks, horiz, label='Frames', **_kwargs): + '''Frame axes''' + n, ticker, labeler = __get_shape_artists(data, horiz) + + positions = np.linspace(0, n-1, n_ticks, endpoint=True).astype(int) + + ticker(positions, positions) + labeler(label) + + +def __log_scale(n): + '''Return a log-scale mapping of bins 0..n, and its inverse. + + Parameters + ---------- + n : int > 0 + Number of bins + + Returns + ------- + y : np.ndarray, shape=(n,) + + y_inv : np.ndarray, shape=(n+1,) + ''' + + logn = np.log2(n) + y = n * (1 - np.logspace(-logn, 0, n, base=2, endpoint=True))[::-1] + y = y.astype(int) + + y_inv = np.arange(len(y)) + for i in range(len(y)-1): + y_inv[y[i]:y[i+1]] = i + + return y, y_inv diff --git a/librosa/effects.py b/librosa/effects.py new file mode 100644 index 0000000000..96c9582d59 --- /dev/null +++ b/librosa/effects.py @@ -0,0 +1,357 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Effects +======= + +Harmonic-percussive source separation +------------------------------------- +.. autosummary:: + :toctree: generated/ + + hpss + harmonic + percussive + +Time and frequency +------------------ +.. autosummary:: + :toctree: generated/ + + time_stretch + pitch_shift + +Miscellaneous +------------- +.. autosummary:: + :toctree: generated/ + + remix +""" + +import numpy as np + +from . import core +from . import decompose +from . import util +from .util.exceptions import ParameterError + +__all__ = ['hpss', 'harmonic', 'percussive', + 'time_stretch', 'pitch_shift', + 'remix'] + + +def hpss(y): + '''Decompose an audio time series into harmonic and percussive components. + + This function automates the STFT->HPSS->ISTFT pipeline, and ensures that + the output waveforms have equal length to the input waveform `y`. + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + Returns + ------- + y_harmonic : np.ndarray [shape=(n,)] + audio time series of the harmonic elements + + y_percussive : np.ndarray [shape=(n,)] + audio time series of the percussive elements + + See Also + -------- + harmonic : Extract only the harmonic component + percussive : Extract only the percussive component + librosa.decompose.hpss : HPSS on spectrograms + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y_harmonic, y_percussive = librosa.effects.hpss(y) + + ''' + + # Compute the STFT matrix + stft = core.stft(y) + + # Decompose into harmonic and percussives + stft_harm, stft_perc = decompose.hpss(stft) + + # Invert the STFTs. Adjust length to match the input. + y_harm = util.fix_length(core.istft(stft_harm, dtype=y.dtype), len(y)) + y_perc = util.fix_length(core.istft(stft_perc, dtype=y.dtype), len(y)) + + return y_harm, y_perc + + +def harmonic(y): + '''Extract harmonic elements from an audio time-series. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + Returns + ------- + y_harmonic : np.ndarray [shape=(n,)] + audio time series of just the harmonic portion + + See Also + -------- + hpss : Separate harmonic and percussive components + percussive : Extract only the percussive component + librosa.decompose.hpss : HPSS for spectrograms + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y_harmonic = librosa.effects.harmonic(y) + + ''' + + # Compute the STFT matrix + stft = core.stft(y) + + # Remove percussives + stft_harm = decompose.hpss(stft)[0] + + # Invert the STFTs + y_harm = util.fix_length(core.istft(stft_harm, dtype=y.dtype), len(y)) + + return y_harm + + +def percussive(y): + '''Extract percussive elements from an audio time-series. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + Returns + ------- + y_percussive : np.ndarray [shape=(n,)] + audio time series of just the percussive portion + + See Also + -------- + hpss : Separate harmonic and percussive components + harmonic : Extract only the harmonic component + librosa.decompose.hpss : HPSS for spectrograms + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y_percussive = librosa.effects.percussive(y) + + ''' + + # Compute the STFT matrix + stft = core.stft(y) + + # Remove harmonics + stft_perc = decompose.hpss(stft)[1] + + # Invert the STFT + y_perc = util.fix_length(core.istft(stft_perc, dtype=y.dtype), len(y)) + + return y_perc + + +def time_stretch(y, rate): + '''Time-stretch an audio series by a fixed rate. + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + rate : float > 0 [scalar] + Stretch factor. If `rate > 1`, then the signal is sped up. + + If `rate < 1`, then the signal is slowed down. + + Returns + ------- + y_stretch : np.ndarray [shape=(rate * n,)] + audio time series stretched by the specified rate + + See Also + -------- + pitch_shift : pitch shifting + librosa.core.phase_vocoder : spectrogram phase vocoder + + + Examples + -------- + Compress to be twice as fast + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y_fast = librosa.effects.time_stretch(y, 2.0) + + Or half the original speed + + >>> y_slow = librosa.effects.time_stretch(y, 0.5) + + ''' + + if rate <= 0: + raise ParameterError('rate must be a positive number') + + # Construct the stft + stft = core.stft(y) + + # Stretch by phase vocoding + stft_stretch = core.phase_vocoder(stft, rate) + + # Invert the stft + y_stretch = core.istft(stft_stretch, dtype=y.dtype) + + return y_stretch + + +def pitch_shift(y, sr, n_steps, bins_per_octave=12): + '''Pitch-shift the waveform by `n_steps` half-steps. + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time-series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + n_steps : float [scalar] + how many (fractional) half-steps to shift `y` + + bins_per_octave : float > 0 [scalar] + how many steps per octave + + + Returns + ------- + y_shift : np.ndarray [shape=(n,)] + The pitch-shifted audio time-series + + + See Also + -------- + time_stretch : time stretching + librosa.core.phase_vocoder : spectrogram phase vocoder + + + Examples + -------- + Shift up by a major third (four half-steps) + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y_third = librosa.effects.pitch_shift(y, sr, n_steps=4) + + Shift down by a tritone (six half-steps) + + >>> y_tritone = librosa.effects.pitch_shift(y, sr, n_steps=-6) + + Shift up by 3 quarter-tones + + >>> y_three_qt = librosa.effects.pitch_shift(y, sr, n_steps=3, + ... bins_per_octave=24) + ''' + + if bins_per_octave < 1 or not np.issubdtype(type(bins_per_octave), np.int): + raise ParameterError('bins_per_octave must be a positive integer.') + + rate = 2.0 ** (-float(n_steps) / bins_per_octave) + + # Stretch in time, then resample + y_shift = core.resample(time_stretch(y, rate), float(sr) / rate, sr) + + # Crop to the same dimension as the input + return util.fix_length(y_shift, len(y)) + + +def remix(y, intervals, align_zeros=True): + '''Remix an audio signal by re-ordering time intervals. + + + Parameters + ---------- + y : np.ndarray [shape=(t,) or (2, t)] + Audio time series + + intervals : iterable of tuples (start, end) + An iterable (list-like or generator) where the `i`th item + `intervals[i]` indicates the start and end (in samples) + of a slice of `y`. + + align_zeros : boolean + If `True`, interval boundaries are mapped to the closest + zero-crossing in `y`. If `y` is stereo, zero-crossings + are computed after converting to mono. + + + Returns + ------- + y_remix : np.ndarray [shape=(d,) or (2, d)] + `y` remixed in the order specified by `intervals` + + + Examples + -------- + Load in the example track and reverse the beats + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + + + Compute beats + + >>> _, beat_frames = librosa.beat.beat_track(y=y, sr=sr, + ... hop_length=512) + + + Convert from frames to sample indices + + >>> beat_samples = librosa.frames_to_samples(beat_frames) + + + Generate intervals from consecutive events + + >>> intervals = librosa.util.frame(beat_samples, frame_length=2, + ... hop_length=1).T + + + Reverse the beat intervals + + >>> y_out = librosa.effects.remix(y, intervals[::-1]) + ''' + + # Validate the audio buffer + util.valid_audio(y, mono=False) + + y_out = [] + + if align_zeros: + y_mono = core.to_mono(y) + zeros = np.nonzero(core.zero_crossings(y_mono))[-1] + # Force end-of-signal onto zeros + zeros = np.append(zeros, [len(y_mono)]) + + clip = [slice(None)] * y.ndim + + for interval in intervals: + + if align_zeros: + interval = zeros[util.match_events(interval, zeros)] + + clip[-1] = slice(interval[0], interval[1]) + + y_out.append(y[clip]) + + return np.concatenate(y_out, axis=-1) diff --git a/librosa/feature/__init__.py b/librosa/feature/__init__.py new file mode 100644 index 0000000000..63702f5333 --- /dev/null +++ b/librosa/feature/__init__.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Feature extraction +================== + +Spectral features +----------------- + +.. autosummary:: + :toctree: generated/ + + chroma_stft + chroma_cqt + melspectrogram + mfcc + rmse + spectral_centroid + spectral_bandwidth + spectral_contrast + spectral_rolloff + poly_features + tonnetz + zero_crossing_rate + +Rhythm features +--------------- +.. autosummary:: + :toctree: generated/ + + tempogram + +Feature manipulation +-------------------- + +.. autosummary:: + :toctree: generated/ + + delta + stack_memory + + +Deprecated +---------- + +.. autosummary:: + :toctree: generated/ + + logfsgram + sync +""" +from .utils import * # pylint: disable=wildcard-import +from .spectral import * # pylint: disable=wildcard-import +from .rhythm import * # pylint: disable=wildcard-import + +__all__ = [_ for _ in dir() if not _.startswith('_')] diff --git a/librosa/feature/rhythm.py b/librosa/feature/rhythm.py new file mode 100644 index 0000000000..42c48deded --- /dev/null +++ b/librosa/feature/rhythm.py @@ -0,0 +1,153 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +'''Rhythmic feature extraction''' + +import numpy as np +import scipy.signal +import six + +from .. import util + +from ..core.audio import autocorrelate +from ..util.exceptions import ParameterError + + +__all__ = ['tempogram'] + + +# -- Rhythmic features -- # +def tempogram(y=None, sr=22050, onset_envelope=None, hop_length=512, + win_length=384, center=True, window=None, norm=np.inf): + '''Compute the tempogram: local autocorrelation of the onset strength envelope. [1]_ + + .. [1] Grosche, Peter, Meinard Müller, and Frank Kurth. + "Cyclic tempogram - A mid-level tempo representation for music signals." + ICASSP, 2010. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + Audio time series. + + sr : number > 0 [scalar] + sampling rate of `y` + + onset_envelope : np.ndarray [shape=(n,)] or None + Optional pre-computed onset strength envelope as provided by + `onset.onset_strength` + + hop_length : int > 0 + number of audio samples between successive onset measurements + + win_length : int > 0 + length of the onset autocorrelation window (in frames/onset measurements) + The default settings (384) corresponds to `384 * hop_length / sr ~= 8.9s`. + + center : bool + If `True`, onset autocorrelation windows are centered. + If `False`, windows are left-aligned. + + window : None, function, np.ndarray [shape=(win_length,)] + Window function to apply to onset strength function. + By default (`None`), an asymmetric Hann window. + + norm : {np.inf, -np.inf, 0, float > 0, None} + Normalization mode. Set to `None` to disable normalization. + + Returns + ------- + tempogram : np.ndarray [shape=(win_length, n)] + Localized autocorrelation of the onset strength envelope + + Raises + ------ + ParameterError + if neither `y` nor `onset_envelope` are provided + + if `win_length < 1` + + if `window` is an array and `len(window) != win_length` + + See Also + -------- + librosa.onset.onset_strength + librosa.util.normalize + librosa.core.stft + + + Examples + -------- + >>> # Compute local onset autocorrelation + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> hop_length = 512 + >>> oenv = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop_length) + >>> tempogram = librosa.feature.tempogram(onset_envelope=oenv, sr=sr, + ... hop_length=hop_length) + >>> # Compute global onset autocorrelation + >>> ac_global = librosa.autocorrelate(oenv, max_size=tempogram.shape[0]) + >>> ac_global = librosa.util.normalize(ac_global) + >>> # Estimate the global tempo for display purposes + >>> tempo = librosa.beat.estimate_tempo(oenv, sr=sr, hop_length=hop_length) + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(8, 6)) + >>> plt.subplot(3, 1, 1) + >>> plt.plot(oenv, label='Onset strength') + >>> plt.xticks([]) + >>> plt.legend(frameon=True) + >>> plt.axis('tight') + >>> plt.subplot(3, 1, 2) + >>> # We'll truncate the display to a narrower range of tempi + >>> librosa.display.specshow(tempogram[:100], sr=sr, hop_length=hop_length, + >>> x_axis='time', y_axis='tempo', + ... tmin=tempo/4, tmax=2*tempo, n_yticks=4) + >>> plt.subplot(3, 1, 3) + >>> x = np.linspace(0, tempogram.shape[0] * float(hop_length) / sr, num=tempogram.shape[0]) + >>> plt.plot(x, np.mean(tempogram, axis=1), label='Mean local autocorrelation') + >>> plt.plot(x, ac_global, '--', alpha=0.75, label='Global autocorrelation') + >>> plt.xlabel('Lag (seconds)') + >>> plt.axis('tight') + >>> plt.legend(frameon=True) + >>> plt.tight_layout() + ''' + + from ..onset import onset_strength + + if win_length < 1: + raise ParameterError('win_length must be a positive integer') + + if window is None: + ac_window = scipy.signal.hann(win_length, sym=False) + elif six.callable(window): + ac_window = window(win_length) + else: + ac_window = np.asarray(window) + if ac_window.size != win_length: + raise ParameterError('Size mismatch between win_length and len(window)') + + if onset_envelope is None: + if y is None: + raise ParameterError('Either y or onset_envelope must be provided') + + onset_envelope = onset_strength(y=y, sr=sr, + hop_length=hop_length) + + # Pad the envelope so that autocorrelation windows are centered on the input + n = len(onset_envelope) + + if center: + onset_envelope = np.pad(onset_envelope, int(win_length // 2), + mode='linear_ramp', end_values=[0, 0]) + + # Carve onset envelope into frames + odf_frame = util.frame(onset_envelope, + frame_length=win_length, + hop_length=1) + + # Truncate to the length of the original signal + if center: + odf_frame = odf_frame[:, :n] + + # Window, autocorrelate, and normalize + return util.normalize(autocorrelate(odf_frame * ac_window[:, np.newaxis], axis=0), + norm=norm, axis=0) diff --git a/librosa/feature/spectral.py b/librosa/feature/spectral.py new file mode 100644 index 0000000000..eb094a323b --- /dev/null +++ b/librosa/feature/spectral.py @@ -0,0 +1,1297 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Spectral feature extraction""" + +import numpy as np + +from .. import util +from .. import filters +from ..util.exceptions import ParameterError +from ..util import Deprecated, rename_kw + +from ..core.time_frequency import fft_frequencies +from ..core.audio import zero_crossings +from ..core.spectrum import logamplitude, _spectrogram +from ..core.constantq import cqt, hybrid_cqt +from ..core.pitch import estimate_tuning + + +__all__ = ['spectral_centroid', + 'spectral_bandwidth', + 'spectral_contrast', + 'spectral_rolloff', + 'poly_features', + 'rmse', + 'zero_crossing_rate', + 'chroma_stft', + 'chroma_cqt', + 'melspectrogram', + 'mfcc', + 'tonnetz', + # Deprecated functions + 'logfsgram', + 'chromagram'] + + +# -- Spectral features -- # +def spectral_centroid(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + freq=None): + '''Compute the spectral centroid. + + Each frame of a magnitude spectrogram is normalized and treated as a + distribution over frequency bins, from which the mean (centroid) is + extracted per frame. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + freq : None or np.ndarray [shape=(d,) or shape=(d, t)] + Center frequencies for spectrogram bins. + If `None`, then FFT bin center frequencies are used. + Otherwise, it can be a single array of `d` center frequencies, + or a matrix of center frequencies as constructed by + `librosa.core.ifgram` + + Returns + ------- + centroid : np.ndarray [shape=(1, t)] + centroid frequencies + + See Also + -------- + librosa.core.stft + Short-time Fourier Transform + + librosa.core.ifgram + Instantaneous-frequency spectrogram + + Examples + -------- + From time-series input: + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> cent = librosa.feature.spectral_centroid(y=y, sr=sr) + >>> cent + array([[ 4382.894, 626.588, ..., 5037.07 , 5413.398]]) + + From spectrogram input: + + >>> S, phase = librosa.magphase(librosa.stft(y=y)) + >>> librosa.feature.spectral_centroid(S=S) + array([[ 4382.894, 626.588, ..., 5037.07 , 5413.398]]) + + Using variable bin center frequencies: + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> if_gram, D = librosa.ifgram(y) + >>> librosa.feature.spectral_centroid(S=np.abs(D), freq=if_gram) + array([[ 4420.719, 625.769, ..., 5011.86 , 5221.492]]) + + Plot the result + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> plt.semilogy(cent.T, label='Spectral centroid') + >>> plt.ylabel('Hz') + >>> plt.xticks([]) + >>> plt.xlim([0, cent.shape[-1]]) + >>> plt.legend() + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('log Power spectrogram') + >>> plt.tight_layout() + ''' + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + if not np.isrealobj(S): + raise ParameterError('Spectral centroid is only defined ' + 'with real-valued input') + elif np.any(S < 0): + raise ParameterError('Spectral centroid is only defined ' + 'with non-negative energies') + + # Compute the center frequencies of each bin + if freq is None: + freq = fft_frequencies(sr=sr, n_fft=n_fft) + + if freq.ndim == 1: + freq = freq.reshape((-1, 1)) + + # Column-normalize S + return np.sum(freq * util.normalize(S, norm=1, axis=0), + axis=0, keepdims=True) + + +def spectral_bandwidth(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + freq=None, centroid=None, norm=True, p=2): + '''Compute p'th-order spectral bandwidth: + + (sum_k S[k] * (freq[k] - centroid)**p)**(1/p) + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + freq : None or np.ndarray [shape=(d,) or shape=(d, t)] + Center frequencies for spectrogram bins. + If `None`, then FFT bin center frequencies are used. + Otherwise, it can be a single array of `d` center frequencies, + or a matrix of center frequencies as constructed by + `librosa.core.ifgram` + + centroid : None or np.ndarray [shape=(1, t)] + pre-computed centroid frequencies + + norm : bool + Normalize per-frame spectral energy (sum to one) + + p : float > 0 + Power to raise deviation from spectral centroid. + + + Returns + ------- + bandwidth : np.ndarray [shape=(1, t)] + frequency bandwidth for each frame + + + Examples + -------- + From time-series input + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> spec_bw = librosa.feature.spectral_bandwidth(y=y, sr=sr) + >>> spec_bw + array([[ 3379.878, 1429.486, ..., 3235.214, 3080.148]]) + + From spectrogram input + + >>> S, phase = librosa.magphase(librosa.stft(y=y)) + >>> librosa.feature.spectral_bandwidth(S=S) + array([[ 3379.878, 1429.486, ..., 3235.214, 3080.148]]) + + Using variable bin center frequencies + + >>> if_gram, D = librosa.ifgram(y) + >>> librosa.feature.spectral_bandwidth(S=np.abs(D), freq=if_gram) + array([[ 3380.011, 1429.11 , ..., 3235.22 , 3080.148]]) + + Plot the result + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> plt.semilogy(spec_bw.T, label='Spectral bandwidth') + >>> plt.ylabel('Hz') + >>> plt.xticks([]) + >>> plt.xlim([0, spec_bw.shape[-1]]) + >>> plt.legend() + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('log Power spectrogram') + >>> plt.tight_layout() + + ''' + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + if not np.isrealobj(S): + raise ParameterError('Spectral bandwidth is only defined ' + 'with real-valued input') + elif np.any(S < 0): + raise ParameterError('Spectral bandwidth is only defined ' + 'with non-negative energies') + + if centroid is None: + centroid = spectral_centroid(y=y, sr=sr, S=S, + n_fft=n_fft, + hop_length=hop_length, + freq=freq) + + # Compute the center frequencies of each bin + if freq is None: + freq = fft_frequencies(sr=sr, n_fft=n_fft) + + if freq.ndim == 1: + deviation = np.abs(np.subtract.outer(freq, np.squeeze(centroid))) + else: + deviation = np.abs(freq - np.squeeze(centroid)) + + # Column-normalize S + if norm: + S = util.normalize(S, norm=1, axis=0) + + return np.sum(S * deviation**p, axis=0, keepdims=True)**(1./p) + + +def spectral_contrast(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + freq=None, fmin=200.0, n_bands=6, quantile=0.02, + linear=False): + '''Compute spectral contrast [1]_ + + .. [1] Jiang, Dan-Ning, Lie Lu, Hong-Jiang Zhang, Jian-Hua Tao, + and Lian-Hong Cai. + "Music type classification by spectral contrast feature." + In Multimedia and Expo, 2002. ICME'02. Proceedings. + 2002 IEEE International Conference on, vol. 1, pp. 113-116. + IEEE, 2002. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + freq : None or np.ndarray [shape=(d,)] + Center frequencies for spectrogram bins. + If `None`, then FFT bin center frequencies are used. + Otherwise, it can be a single array of `d` center frequencies. + + fmin : float > 0 + Frequency cutoff for the first bin `[0, fmin]` + Subsequent bins will cover `[fmin, 2*fmin]`, `[2*fmin, 4*fmin]`, etc. + + n_bands : int > 1 + number of frequency bands + + quantile : float in (0, 1) + quantile for determining peaks and valleys + + linear : bool + If `True`, return the linear difference of magnitudes: + `peaks - valleys`. + + If `False`, return the logarithmic difference: + `log(peaks) - log(valleys)`. + + + Returns + ------- + contrast : np.ndarray [shape=(n_bands + 1, t)] + each row of spectral contrast values corresponds to a given + octave-based frequency + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + >>> contrast = librosa.feature.spectral_contrast(S=S, sr=sr) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(S ** 2, + ... ref_power=np.max), + ... y_axis='log') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Power spectrogram') + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(contrast, x_axis='time') + >>> plt.colorbar() + >>> plt.ylabel('Frequency bands') + >>> plt.title('Spectral contrast') + >>> plt.tight_layout() + ''' + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + # Compute the center frequencies of each bin + if freq is None: + freq = fft_frequencies(sr=sr, n_fft=n_fft) + + freq = np.atleast_1d(freq) + + if freq.ndim != 1 or len(freq) != S.shape[0]: + raise ParameterError('freq.shape mismatch: expected ' + '({:d},)'.format(S.shape[0])) + + if n_bands < 1 or not isinstance(n_bands, int): + raise ParameterError('n_bands must be a positive integer') + + if not (0.0 < quantile < 1.0): + raise ParameterError('quantile must lie in the range (0, 1)') + + if fmin <= 0: + raise ParameterError('fmin must be a positive number') + + octa = np.zeros(n_bands + 2) + octa[1:] = fmin * (2.0**np.arange(0, n_bands + 1)) + + valley = np.zeros((n_bands + 1, S.shape[1])) + peak = np.zeros_like(valley) + + for k, (f_low, f_high) in enumerate(zip(octa[:-1], octa[1:])): + current_band = np.logical_and(freq >= f_low, freq <= f_high) + + idx = np.flatnonzero(current_band) + + if k > 0: + current_band[idx[0] - 1] = True + + if k == n_bands: + current_band[idx[-1] + 1:] = True + + sub_band = S[current_band] + + if k < n_bands: + sub_band = sub_band[:-1] + + # Always take at least one bin from each side + idx = np.rint(quantile * np.sum(current_band)) + idx = int(np.maximum(idx, 1)) + + sortedr = np.sort(sub_band, axis=0) + + valley[k] = np.mean(sortedr[:idx], axis=0) + peak[k] = np.mean(sortedr[-idx:], axis=0) + + if linear: + return peak - valley + else: + return logamplitude(peak) - logamplitude(valley) + + +def spectral_rolloff(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + freq=None, roll_percent=0.85): + '''Compute roll-off frequency + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + freq : None or np.ndarray [shape=(d,) or shape=(d, t)] + Center frequencies for spectrogram bins. + If `None`, then FFT bin center frequencies are used. + Otherwise, it can be a single array of `d` center frequencies, + + .. note:: `freq` is assumed to be sorted in increasing order + + roll_percent : float [0 < roll_percent < 1] + Roll-off percentage. + + Returns + ------- + rolloff : np.ndarray [shape=(1, t)] + roll-off frequency for each frame + + + Examples + -------- + From time-series input + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr) + >>> rolloff + array([[ 8376.416, 968.994, ..., 8925.513, 9108.545]]) + + From spectrogram input + + >>> S, phase = librosa.magphase(librosa.stft(y)) + >>> librosa.feature.spectral_rolloff(S=S, sr=sr) + array([[ 8376.416, 968.994, ..., 8925.513, 9108.545]]) + + >>> # With a higher roll percentage: + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.spectral_rolloff(y=y, sr=sr, roll_percent=0.95) + array([[ 10012.939, 3003.882, ..., 10034.473, 10077.539]]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> plt.semilogy(rolloff.T, label='Roll-off frequency') + >>> plt.ylabel('Hz') + >>> plt.xticks([]) + >>> plt.xlim([0, rolloff.shape[-1]]) + >>> plt.legend() + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('log Power spectrogram') + >>> plt.tight_layout() + + ''' + + if not (0.0 < roll_percent < 1.0): + raise ParameterError('roll_percent must lie in the range (0, 1)') + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + if not np.isrealobj(S): + raise ParameterError('Spectral rolloff is only defined ' + 'with real-valued input') + elif np.any(S < 0): + raise ParameterError('Spectral rolloff is only defined ' + 'with non-negative energies') + + # Compute the center frequencies of each bin + if freq is None: + freq = fft_frequencies(sr=sr, n_fft=n_fft) + + # Make sure that frequency can be broadcast + if freq.ndim == 1: + freq = freq.reshape((-1, 1)) + + total_energy = np.cumsum(S, axis=0) + + threshold = roll_percent * total_energy[-1] + + ind = np.where(total_energy < threshold, np.nan, 1) + + return np.nanmin(ind * freq, axis=0, keepdims=True) + + +def rmse(y=None, S=None, n_fft=2048, hop_length=512): + '''Compute root-mean-square (RMS) energy for each frame. + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + + Returns + ------- + rms : np.ndarray [shape=(1, t)] + RMS value for each frame + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.rmse(y=y) + array([[ 0. , 0.056, ..., 0. , 0. ]], dtype=float32) + + Or from spectrogram input + + >>> S, phase = librosa.magphase(librosa.stft(y)) + >>> rms = librosa.feature.rmse(S=S) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> plt.semilogy(rms.T, label='RMS Energy') + >>> plt.xticks([]) + >>> plt.xlim([0, rms.shape[-1]]) + >>> plt.legend(loc='best') + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('log Power spectrogram') + >>> plt.tight_layout() + + ''' + + S, _ = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + return np.sqrt(np.mean(np.abs(S)**2, axis=0, keepdims=True)) + + +def poly_features(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + order=1, freq=None): + '''Get coefficients of fitting an nth-order polynomial to the columns + of a spectrogram. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) spectrogram magnitude + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + order : int > 0 + order of the polynomial to fit + + freq : None or np.ndarray [shape=(d,) or shape=(d, t)] + Center frequencies for spectrogram bins. + If `None`, then FFT bin center frequencies are used. + Otherwise, it can be a single array of `d` center frequencies, + or a matrix of center frequencies as constructed by + `librosa.core.ifgram` + + Returns + ------- + coefficients : np.ndarray [shape=(order+1, t)] + polynomial coefficients for each frame + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + + Line features + + >>> line = librosa.feature.poly_features(S=S, sr=sr) + >>> line + array([[ -2.406e-08, -5.051e-06, ..., -1.103e-08, -5.651e-09], + [ 3.445e-04, 3.834e-02, ..., 2.661e-04, 2.239e-04]]) + + Quadratic features + + >>> quad = librosa.feature.poly_features(S=S, order=2) + >>> quad + array([[ 6.276e-12, 2.010e-09, ..., 1.493e-12, 1.000e-13], + [ -9.325e-08, -2.721e-05, ..., -2.749e-08, -6.754e-09], + [ 4.715e-04, 7.902e-02, ..., 2.963e-04, 2.259e-04]]) + + Plot the results for comparison + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(line) + >>> plt.colorbar() + >>> plt.title('Line coefficients') + >>> plt.subplot(3, 1, 2) + >>> librosa.display.specshow(quad) + >>> plt.colorbar() + >>> plt.title('Quadratic coefficients') + >>> plt.subplot(3, 1, 3) + >>> librosa.display.specshow(librosa.logamplitude(S**2, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.title('log Power spectrogram') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.tight_layout() + + ''' + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length) + + # Compute the center frequencies of each bin + if freq is None: + freq = fft_frequencies(sr=sr, n_fft=n_fft) + + # If frequencies are constant over frames, then we only need to fit once + if freq.ndim == 1: + coefficients = np.polyfit(freq, S, order) + else: + # Else, fit each frame independently and stack the results + coefficients = np.concatenate([[np.polyfit(freq[:, i], S[:, i], order)] + for i in range(S.shape[1])], axis=0).T + + return coefficients + + +def zero_crossing_rate(y, frame_length=2048, hop_length=512, center=True, + **kwargs): + '''Compute the zero-crossing rate of an audio time series. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + Audio time series + + frame_length : int > 0 + Length of the frame over which to compute zero crossing rates + + hop_length : int > 0 + Number of samples to advance for each frame + + center : bool + If `True`, frames are centered by padding the edges of `y`. + This is similar to the padding in `librosa.core.stft`, + but uses edge-value copies instead of reflection. + + kwargs : additional keyword arguments + See `librosa.core.zero_crossings` + + .. note:: By default, the `pad` parameter is set to `False`, which + differs from the default specified by + `librosa.core.zero_crossings`. + + Returns + ------- + zcr : np.ndarray [shape=(1, t)] + `zcr[0, i]` is the fraction of zero crossings in the + `i` th frame + + See Also + -------- + librosa.core.zero_crossings + Compute zero-crossings in a time-series + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.zero_crossing_rate(y) + array([[ 0.134, 0.139, ..., 0.387, 0.322]]) + + ''' + + util.valid_audio(y) + + if center: + y = np.pad(y, int(frame_length // 2), mode='edge') + + y_framed = util.frame(y, frame_length, hop_length) + + kwargs['axis'] = 0 + kwargs.setdefault('pad', False) + + crossings = zero_crossings(y_framed, **kwargs) + + return np.mean(crossings, axis=0, keepdims=True) + + +# -- Chroma --# +def chroma_stft(y=None, sr=22050, S=None, norm=np.inf, n_fft=2048, + hop_length=512, tuning=None, **kwargs): + """Compute a chromagram from a waveform or power spectrogram. + + This implementation is derived from `chromagram_E` [1]_ + + .. [1] Ellis, Daniel P.W. "Chroma feature analysis and synthesis" + 2007/04/21 + http://labrosa.ee.columbia.edu/matlab/chroma-ansyn/ + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + power spectrogram + + norm : float or None + Column-wise normalization. + See `librosa.util.normalize` for details. + + If `None`, no normalization is performed. + + n_fft : int > 0 [scalar] + FFT window size if provided `y, sr` instead of `S` + + hop_length : int > 0 [scalar] + hop length if provided `y, sr` instead of `S` + + tuning : float in `[-0.5, 0.5)` [scalar] or None. + Deviation from A440 tuning in fractional bins (cents). + If `None`, it is automatically estimated. + + kwargs : additional keyword arguments + Arguments to parameterize chroma filters. + See `librosa.filters.chroma` for details. + + Returns + ------- + chromagram : np.ndarray [shape=(n_chroma, t)] + Normalized energy for each chroma bin at each frame. + + See Also + -------- + librosa.filters.chroma + Chroma filter bank construction + librosa.util.normalize + Vector normalization + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.chroma_stft(y=y, sr=sr) + array([[ 0.974, 0.881, ..., 0.925, 1. ], + [ 1. , 0.841, ..., 0.882, 0.878], + ..., + [ 0.658, 0.985, ..., 0.878, 0.764], + [ 0.969, 0.92 , ..., 0.974, 0.915]]) + + Use an energy (magnitude) spectrum instead of power spectrogram + + >>> S = np.abs(librosa.stft(y)) + >>> chroma = librosa.feature.chroma_stft(S=S, sr=sr) + >>> chroma + array([[ 0.884, 0.91 , ..., 0.861, 0.858], + [ 0.963, 0.785, ..., 0.968, 0.896], + ..., + [ 0.871, 1. , ..., 0.928, 0.829], + [ 1. , 0.982, ..., 0.93 , 0.878]]) + + Use a pre-computed power spectrogram with a larger frame + + >>> S = np.abs(librosa.stft(y, n_fft=4096))**2 + >>> chroma = librosa.feature.chroma_stft(S=S, sr=sr) + >>> chroma + array([[ 0.685, 0.477, ..., 0.961, 0.986], + [ 0.674, 0.452, ..., 0.952, 0.926], + ..., + [ 0.844, 0.575, ..., 0.934, 0.869], + [ 0.793, 0.663, ..., 0.964, 0.972]]) + + >>> import matplotlib.pyplot as plt + >>> librosa.display.specshow(chroma, y_axis='chroma', x_axis='time') + >>> plt.colorbar() + >>> plt.title('Chromagram') + >>> plt.tight_layout() + + """ + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length, + power=2) + + n_chroma = kwargs.get('n_chroma', 12) + + if tuning is None: + tuning = estimate_tuning(S=S, sr=sr, bins_per_octave=n_chroma) + + # Get the filter bank + if 'A440' not in kwargs: + kwargs['A440'] = 440.0 * 2.0**(float(tuning) / n_chroma) + + chromafb = filters.chroma(sr, n_fft, **kwargs) + + # Compute raw chroma + raw_chroma = np.dot(chromafb, S) + + # Compute normalization factor for each frame + return util.normalize(raw_chroma, norm=norm, axis=0) + + +def chroma_cqt(y=None, sr=22050, C=None, hop_length=512, fmin=None, + norm=np.inf, threshold=0.0, tuning=None, n_chroma=12, + n_octaves=7, window=None, bins_per_octave=None, cqt_mode='full', + mode=Deprecated()): + r'''Constant-Q chromagram + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 + sampling rate of `y` + + C : np.ndarray [shape=(d, t)] [Optional] + a pre-computed constant-Q spectrogram + + hop_length : int > 0 + number of samples between successive chroma frames + + fmin : float > 0 + minimum frequency to analyze in the CQT. + Default: 'C2' ~ 32.7 Hz + + norm : int > 0, +-np.inf, or None + Column-wise normalization of the chromagram. + + threshold : float + Pre-normalization energy threshold. Values below the + threshold are discarded, resulting in a sparse chromagram. + + tuning : float + Deviation (in cents) from A440 tuning + + n_chroma : int > 0 + Number of chroma bins to produce + + n_octaves : int > 0 + Number of octaves to analyze above `fmin` + + window : None or np.ndarray + Optional window parameter to `filters.cq_to_chroma` + + bins_per_octave : int > 0 + Number of bins per octave in the CQT. + Default: matches `n_chroma` + + cqt_mode : ['full', 'hybrid'] + Constant-Q transform mode + + mode : str + .. warning:: This parameter name was in librosa 0.4.2 + Use the `cqt_mode` parameter instead. + The `mode` parameter will be removed in librosa 0.5.0. + + Returns + ------- + chromagram : np.ndarray [shape=(n_chroma, t)] + The output chromagram + + See Also + -------- + librosa.util.normalize + librosa.core.cqt + librosa.core.hybrid_cqt + chroma_stft + + Examples + -------- + Compare a long-window STFT chromagram to the CQT chromagram + + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... offset=10, duration=15) + >>> chroma_stft = librosa.feature.chroma_stft(y=y, sr=sr, + ... n_chroma=12, n_fft=4096) + >>> chroma_cq = librosa.feature.chroma_cqt(y=y, sr=sr) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2,1,1) + >>> librosa.display.specshow(chroma_stft, y_axis='chroma') + >>> plt.title('chroma_stft') + >>> plt.colorbar() + >>> plt.subplot(2,1,2) + >>> librosa.display.specshow(chroma_cq, y_axis='chroma', x_axis='time') + >>> plt.title('chroma_cqt') + >>> plt.colorbar() + >>> plt.tight_layout() + + ''' + + cqt_func = {'full': cqt, 'hybrid': hybrid_cqt} + + cqt_mode = rename_kw('mode', mode, 'cqt_mode', cqt_mode, '0.4.2', '0.5.0') + + if bins_per_octave is None: + bins_per_octave = n_chroma + + # Build the CQT if we don't have one already + if C is None: + C = np.abs(cqt_func[cqt_mode](y, sr=sr, + hop_length=hop_length, + fmin=fmin, + n_bins=n_octaves * bins_per_octave, + bins_per_octave=bins_per_octave, + tuning=tuning, + real=False)) + + # Map to chroma + cq_to_chr = filters.cq_to_chroma(C.shape[0], + bins_per_octave=bins_per_octave, + n_chroma=n_chroma, + fmin=fmin, + window=window) + chroma = cq_to_chr.dot(C) + + if threshold is not None: + chroma[chroma < threshold] = 0.0 + + # Normalize + if norm is not None: + chroma = util.normalize(chroma, norm=norm, axis=0) + + return chroma + + +def tonnetz(y=None, sr=22050, chroma=None): + '''Computes the tonal centroid features (tonnetz), following the method of + [1]_. + + .. [1] Harte, C., Sandler, M., & Gasser, M. (2006). "Detecting Harmonic + Change in Musical Audio." In Proceedings of the 1st ACM Workshop + on Audio and Music Computing Multimedia (pp. 21-26). + Santa Barbara, CA, USA: ACM Press. doi:10.1145/1178723.1178727. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + Audio time series. + + sr : number > 0 [scalar] + sampling rate of `y` + + chroma : np.ndarray [shape=(n_chroma, t)] or None + Normalized energy for each chroma bin at each frame. + + If `None`, a cqt chromagram is performed. + + Returns + ------- + tonnetz : np.ndarray [shape(6, t)] + Tonal centroid features for each frame. + + Tonnetz dimensions: + - 0: Fifth x-axis + - 1: Fifth y-axis + - 2: Minor x-axis + - 3: Minor y-axis + - 4: Major x-axis + - 5: Major y-axis + + See Also + -------- + chroma_cqt + Compute a chromagram from a constant-Q transform. + + chroma_stft + Compute a chromagram from an STFT spectrogram or waveform. + + Examples + -------- + Compute tonnetz features from the harmonic component of a song + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> y = librosa.effects.harmonic(y) + >>> tonnetz = librosa.feature.tonnetz(y=y, sr=sr) + >>> tonnetz + array([[-0.073, -0.053, ..., -0.054, -0.073], + [ 0.001, 0.001, ..., -0.054, -0.062], + ..., + [ 0.039, 0.034, ..., 0.044, 0.064], + [ 0.005, 0.002, ..., 0.011, 0.017]]) + + Compare the tonnetz features to `chroma_cqt` + + >>> import matplotlib.pyplot as plt + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(tonnetz, y_axis='tonnetz') + >>> plt.colorbar() + >>> plt.title('Tonal Centroids (Tonnetz)') + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(librosa.feature.chroma_cqt(y, sr=sr), + ... y_axis='chroma', x_axis='time') + >>> plt.colorbar() + >>> plt.title('Chroma') + >>> plt.tight_layout() + + ''' + + if y is None and chroma is None: + raise ParameterError('Either the audio samples or the chromagram must be ' + 'passed as an argument.') + + if chroma is None: + chroma = chroma_cqt(y=y, sr=sr) + + # Generate Transformation matrix + dim_map = np.linspace(0, 12, num=chroma.shape[0], endpoint=False) + + scale = np.asarray([7. / 6, 7. / 6, + 3. / 2, 3. / 2, + 2. / 3, 2. / 3]) + + V = np.multiply.outer(scale, dim_map) + + # Even rows compute sin() + V[::2] -= 0.5 + + R = np.array([1, 1, # Fifths + 1, 1, # Minor + 0.5, 0.5]) # Major + + phi = R[:, np.newaxis] * np.cos(np.pi * V) + + # Do the transform to tonnetz + return phi.dot(util.normalize(chroma, norm=1, axis=0)) + + +# -- Mel spectrogram and MFCCs -- # +def mfcc(y=None, sr=22050, S=None, n_mfcc=20, **kwargs): + """Mel-frequency cepstral coefficients + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + log-power Mel spectrogram + + n_mfcc: int > 0 [scalar] + number of MFCCs to return + + kwargs : additional keyword arguments + Arguments to `melspectrogram`, if operating + on time series input + + Returns + ------- + M : np.ndarray [shape=(n_mfcc, t)] + MFCC sequence + + See Also + -------- + melspectrogram + + Examples + -------- + Generate mfccs from a time series + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.mfcc(y=y, sr=sr) + array([[ -5.229e+02, -4.944e+02, ..., -5.229e+02, -5.229e+02], + [ 7.105e-15, 3.787e+01, ..., -7.105e-15, -7.105e-15], + ..., + [ 1.066e-14, -7.500e+00, ..., 1.421e-14, 1.421e-14], + [ 3.109e-14, -5.058e+00, ..., 2.931e-14, 2.931e-14]]) + + Use a pre-computed log-power Mel spectrogram + + >>> S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, + ... fmax=8000) + >>> librosa.feature.mfcc(S=librosa.logamplitude(S)) + array([[ -5.207e+02, -4.898e+02, ..., -5.207e+02, -5.207e+02], + [ -2.576e-14, 4.054e+01, ..., -3.997e-14, -3.997e-14], + ..., + [ 7.105e-15, -3.534e+00, ..., 0.000e+00, 0.000e+00], + [ 3.020e-14, -2.613e+00, ..., 3.553e-14, 3.553e-14]]) + + Get more components + + >>> mfccs = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40) + + Visualize the MFCC series + + >>> import matplotlib.pyplot as plt + >>> librosa.display.specshow(mfccs, x_axis='time') + >>> plt.colorbar() + >>> plt.title('MFCC') + >>> plt.tight_layout() + + + """ + + if S is None: + S = logamplitude(melspectrogram(y=y, sr=sr, **kwargs)) + + return np.dot(filters.dct(n_mfcc, S.shape[0]), S) + + +def melspectrogram(y=None, sr=22050, S=None, n_fft=2048, hop_length=512, + **kwargs): + """Compute a Mel-scaled power spectrogram. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time-series + + sr : number > 0 [scalar] + sampling rate of `y` + + S : np.ndarray [shape=(d, t)] + power spectrogram + + n_fft : int > 0 [scalar] + length of the FFT window + + hop_length : int > 0 [scalar] + number of samples between successive frames. + See `librosa.core.stft` + + kwargs : additional keyword arguments + Mel filter bank parameters. + See `librosa.filters.mel` for details. + + Returns + ------- + S : np.ndarray [shape=(n_mels, t)] + Mel power spectrogram + + See Also + -------- + librosa.filters.mel + Mel filter bank construction + + librosa.core.stft + Short-time Fourier Transform + + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.feature.melspectrogram(y=y, sr=sr) + array([[ 2.891e-07, 2.548e-03, ..., 8.116e-09, 5.633e-09], + [ 1.986e-07, 1.162e-02, ..., 9.332e-08, 6.716e-09], + ..., + [ 3.668e-09, 2.029e-08, ..., 3.208e-09, 2.864e-09], + [ 2.561e-10, 2.096e-09, ..., 7.543e-10, 6.101e-10]]) + + Using a pre-computed power spectrogram + + >>> D = np.abs(librosa.stft(y))**2 + >>> S = librosa.feature.melspectrogram(S=D) + + >>> # Passing through arguments to the Mel filters + >>> S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, + ... fmax=8000) + + >>> import matplotlib.pyplot as plt + >>> librosa.display.specshow(librosa.logamplitude(S, + ... ref_power=np.max), + ... y_axis='mel', fmax=8000, + ... x_axis='time') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Mel spectrogram') + >>> plt.tight_layout() + + + """ + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length, + power=2) + + # Build a Mel filter + mel_basis = filters.mel(sr, n_fft, **kwargs) + + return np.dot(mel_basis, S) + + +# Deprecated functions +@util.decorators.deprecated('0.4', '0.5') +def logfsgram(y=None, sr=22050, S=None, n_fft=2048, + hop_length=512, **kwargs): # pragma: no cover + '''Compute a log-frequency spectrogram using a + fixed-window STFT. + + .. warning:: Deprecated in librosa 0.4 + Functionality is superseded by `librosa.core.pseudo_cqt` + + Parameters + ---------- + y : np.ndarray [shape=(n,)] or None + audio time series + + sr : number > 0 [scalar] + audio sampling rate of `y` + + S : np.ndarray [shape=(d, t)] or None + (optional) power spectrogram + + n_fft : int > 0 [scalar] + FFT window size + + hop_length : int > 0 [scalar] + hop length for STFT. See `librosa.core.stft` for details. + + bins_per_octave : int > 0 [scalar] + Number of bins per octave. Defaults to 12. + + tuning : float in `[-0.5, 0.5)` [scalar] + Deviation (in fractions of a bin) from A440 tuning. + + If not provided, it will be automatically estimated. + + kwargs : additional keyword arguments + See `librosa.filters.logfrequency` + + Returns + ------- + P : np.ndarray [shape=(n_pitches, t)] + `P[f, t]` contains the energy at pitch bin `f`, frame `t`. + + + Examples + -------- + From time-series input + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> L = librosa.feature.logfsgram(y=y, sr=sr) + >>> L + array([[ 1.309e-02, 1.228e+00, ..., 3.785e-08, 7.624e-09], + [ 1.630e-24, 1.528e-22, ..., 4.710e-30, 9.488e-31], + ..., + [ 2.617e-05, 3.807e-04, ..., 6.387e-08, 6.000e-08], + [ 3.214e-05, 3.814e-04, ..., 7.599e-08, 6.046e-08]]) + + Plot the pseudo CQT + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(librosa.logamplitude(L, + ... ref_power=np.max), + ... y_axis='cqt_hz', x_axis='time') + >>> plt.title('Log-frequency power spectrogram') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.tight_layout() + + ''' + + S, n_fft = _spectrogram(y=y, S=S, n_fft=n_fft, hop_length=hop_length, + power=2) + + # If we don't have tuning already, grab it from S + if 'tuning' not in kwargs: + bins_per_oct = kwargs.get('bins_per_octave', 12) + kwargs['tuning'] = estimate_tuning(S=S, sr=sr, + bins_per_octave=bins_per_oct) + + # Build the CQ basis + cq_basis = filters.logfrequency(sr, n_fft=n_fft, **kwargs) + + return cq_basis.dot(S) + + +# Moved functions +chromagram = util.decorators.moved('librosa.feature.chromagram', + '0.4', '0.5')(chroma_stft) diff --git a/librosa/feature/utils.py b/librosa/feature/utils.py new file mode 100644 index 0000000000..d67e0ef18f --- /dev/null +++ b/librosa/feature/utils.py @@ -0,0 +1,237 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Feature manipulation utilities""" + +import numpy as np +import scipy.signal + +from .. import cache +from .. import util +from ..util.exceptions import ParameterError + +__all__ = ['delta', + 'stack_memory', + # Moved/deprecated + 'sync'] + + +@cache +def delta(data, width=9, order=1, axis=-1, trim=True): + r'''Compute delta features: local estimate of the derivative + of the input data along the selected axis. + + + Parameters + ---------- + data : np.ndarray + the input data matrix (eg, spectrogram) + + width : int >= 3, odd [scalar] + Number of frames over which to compute the delta feature + + order : int > 0 [scalar] + the order of the difference operator. + 1 for first derivative, 2 for second, etc. + + axis : int [scalar] + the axis along which to compute deltas. + Default is -1 (columns). + + trim : bool + set to `True` to trim the output matrix to the original size. + + Returns + ------- + delta_data : np.ndarray [shape=(d, t) or (d, t + window)] + delta matrix of `data`. + + Examples + -------- + Compute MFCC deltas, delta-deltas + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfcc = librosa.feature.mfcc(y=y, sr=sr) + >>> mfcc_delta = librosa.feature.delta(mfcc) + >>> mfcc_delta + array([[ 2.929e+01, 3.090e+01, ..., 0.000e+00, 0.000e+00], + [ 2.226e+01, 2.553e+01, ..., 3.944e-31, 3.944e-31], + ..., + [ -1.192e+00, -6.099e-01, ..., 9.861e-32, 9.861e-32], + [ -5.349e-01, -2.077e-01, ..., 1.183e-30, 1.183e-30]]) + >>> mfcc_delta2 = librosa.feature.delta(mfcc, order=2) + >>> mfcc_delta2 + array([[ 1.281e+01, 1.020e+01, ..., 0.000e+00, 0.000e+00], + [ 2.726e+00, 3.558e+00, ..., 0.000e+00, 0.000e+00], + ..., + [ -1.702e-01, -1.509e-01, ..., 0.000e+00, 0.000e+00], + [ -9.021e-02, -7.007e-02, ..., -2.190e-47, -2.190e-47]]) + + >>> import matplotlib.pyplot as plt + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(mfcc) + >>> plt.title('MFCC') + >>> plt.colorbar() + >>> plt.subplot(3, 1, 2) + >>> librosa.display.specshow(mfcc_delta) + >>> plt.title(r'MFCC-$\Delta$') + >>> plt.colorbar() + >>> plt.subplot(3, 1, 3) + >>> librosa.display.specshow(mfcc_delta2, x_axis='time') + >>> plt.title(r'MFCC-$\Delta^2$') + >>> plt.colorbar() + >>> plt.tight_layout() + + ''' + + data = np.atleast_1d(data) + + if width < 3 or np.mod(width, 2) != 1: + raise ParameterError('width must be an odd integer >= 3') + + if order <= 0 or not isinstance(order, int): + raise ParameterError('order must be a positive integer') + + half_length = 1 + int(width // 2) + window = np.arange(half_length - 1., -half_length, -1.) + + # Normalize the window so we're scale-invariant + window /= np.sum(np.abs(window)**2) + + # Pad out the data by repeating the border values (delta=0) + padding = [(0, 0)] * data.ndim + width = int(width) + padding[axis] = (width, width) + delta_x = np.pad(data, padding, mode='edge') + + for _ in range(order): + delta_x = scipy.signal.lfilter(window, 1, delta_x, axis=axis) + + # Cut back to the original shape of the input data + if trim: + idx = [slice(None)] * delta_x.ndim + idx[axis] = slice(- half_length - data.shape[axis], - half_length) + delta_x = delta_x[idx] + + return delta_x + + +@cache +def stack_memory(data, n_steps=2, delay=1, **kwargs): + """Short-term history embedding: vertically concatenate a data + vector or matrix with delayed copies of itself. + + Each column `data[:, i]` is mapped to:: + + data[:, i] -> [data[:, i], + data[:, i - delay], + ... + data[:, i - (n_steps-1)*delay]] + + For columns `i < (n_steps - 1) * delay` , the data will be padded. + By default, the data is padded with zeros, but this behavior can be + overridden by supplying additional keyword arguments which are passed + to `np.pad()`. + + + Parameters + ---------- + data : np.ndarray [shape=(t,) or (d, t)] + Input data matrix. If `data` is a vector (`data.ndim == 1`), + it will be interpreted as a row matrix and reshaped to `(1, t)`. + + n_steps : int > 0 [scalar] + embedding dimension, the number of steps back in time to stack + + delay : int > 0 [scalar] + the number of columns to step + + kwargs : additional keyword arguments + Additional arguments to pass to `np.pad`. + + Returns + ------- + data_history : np.ndarray [shape=(m * d, t)] + data augmented with lagged copies of itself, + where `m == n_steps - 1`. + + Examples + -------- + Keep two steps (current and previous) + + >>> data = np.arange(-3, 3) + >>> librosa.feature.stack_memory(data) + array([[-3, -2, -1, 0, 1, 2], + [ 0, -3, -2, -1, 0, 1]]) + + Or three steps + + >>> librosa.feature.stack_memory(data, n_steps=3) + array([[-3, -2, -1, 0, 1, 2], + [ 0, -3, -2, -1, 0, 1], + [ 0, 0, -3, -2, -1, 0]]) + + Use reflection padding instead of zero-padding + + >>> librosa.feature.stack_memory(data, n_steps=3, mode='reflect') + array([[-3, -2, -1, 0, 1, 2], + [-2, -3, -2, -1, 0, 1], + [-1, -2, -3, -2, -1, 0]]) + + Or pad with edge-values, and delay by 2 + + >>> librosa.feature.stack_memory(data, n_steps=3, delay=2, mode='edge') + array([[-3, -2, -1, 0, 1, 2], + [-3, -3, -3, -2, -1, 0], + [-3, -3, -3, -3, -3, -2]]) + + Stack time-lagged beat-synchronous chroma edge padding + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> chroma = librosa.feature.chroma_stft(y=y, sr=sr) + >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr, hop_length=512) + >>> chroma_sync = librosa.util.sync(chroma, beats) + >>> chroma_lag = librosa.feature.stack_memory(chroma_sync, n_steps=3, + ... mode='edge') + + Plot the result + + >>> import matplotlib.pyplot as plt + >>> librosa.display.specshow(chroma_lag, y_axis='chroma') + >>> librosa.display.time_ticks(librosa.frames_to_time(beats, sr=sr)) + >>> plt.yticks([0, 12, 24], ['Lag=0', 'Lag=1', 'Lag=2']) + >>> plt.title('Time-lagged chroma') + >>> plt.colorbar() + >>> plt.tight_layout() + """ + + if n_steps < 1: + raise ParameterError('n_steps must be a positive integer') + + if delay < 1: + raise ParameterError('delay must be a positive integer') + + data = np.atleast_2d(data) + + t = data.shape[1] + kwargs.setdefault('mode', 'constant') + + if kwargs['mode'] == 'constant': + kwargs.setdefault('constant_values', [0]) + + # Pad the end with zeros, which will roll to the front below + data = np.pad(data, [(0, 0), (int((n_steps - 1) * delay), 0)], **kwargs) + + history = data + + for i in range(1, n_steps): + history = np.vstack([np.roll(data, -i * delay, axis=1), history]) + + # Trim to original width + history = history[:, :t] + + # Make contiguous + return np.ascontiguousarray(history.T).T + +# Moved/deprecated functions +sync = util.decorators.moved('librosa.feature.sync', + '0.4.1', '0.5')(util.sync) diff --git a/librosa/filters.py b/librosa/filters.py new file mode 100644 index 0000000000..44ba14f894 --- /dev/null +++ b/librosa/filters.py @@ -0,0 +1,854 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Filters +======= + +Filter bank construction +------------------------ +.. autosummary:: + :toctree: generated/ + + dct + mel + chroma + constant_q + +Miscellaneous +------------- +.. autosummary:: + :toctree: generated/ + + constant_q_lengths + cq_to_chroma + window_bandwidth + +Deprecated +---------- +.. autosummary:: + :toctree: generated/ + + logfrequency +""" + +import numpy as np +import scipy +import scipy.signal +import warnings + +from . import cache +from . import util +from .util.exceptions import ParameterError + +from .core.time_frequency import note_to_hz, hz_to_midi, hz_to_octs +from .core.time_frequency import fft_frequencies, mel_frequencies + +# Dictionary of window function bandwidths +WINDOW_BANDWIDTHS = dict(hann=0.725) + +__all__ = ['dct', + 'mel', + 'chroma', + 'constant_q', + 'constant_q_lengths', + 'cq_to_chroma', + 'window_bandwidth', + # Deprecated + 'logfrequency'] + + +@cache +def dct(n_filters, n_input): + """Discrete cosine transform (DCT type-III) basis. + + .. [1] http://en.wikipedia.org/wiki/Discrete_cosine_transform + + Parameters + ---------- + n_filters : int > 0 [scalar] + number of output components (DCT filters) + + n_input : int > 0 [scalar] + number of input components (frequency bins) + + Returns + ------- + dct_basis: np.ndarray [shape=(n_filters, n_input)] + DCT (type-III) basis vectors [1]_ + + Examples + -------- + >>> n_fft = 2048 + >>> dct_filters = librosa.filters.dct(13, 1 + n_fft // 2) + >>> dct_filters + array([[ 0.031, 0.031, ..., 0.031, 0.031], + [ 0.044, 0.044, ..., -0.044, -0.044], + ..., + [ 0.044, 0.044, ..., -0.044, -0.044], + [ 0.044, 0.044, ..., 0.044, 0.044]]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(dct_filters, x_axis='linear') + >>> plt.ylabel('DCT function') + >>> plt.title('DCT filter bank') + >>> plt.colorbar() + >>> plt.tight_layout() + """ + + basis = np.empty((n_filters, n_input)) + basis[0, :] = 1.0 / np.sqrt(n_input) + + samples = np.arange(1, 2*n_input, 2) * np.pi / (2.0 * n_input) + + for i in range(1, n_filters): + basis[i, :] = np.cos(i*samples) * np.sqrt(2.0/n_input) + + return basis + + +@cache +def mel(sr, n_fft, n_mels=128, fmin=0.0, fmax=None, htk=False): + """Create a Filterbank matrix to combine FFT bins into Mel-frequency bins + + Parameters + ---------- + sr : number > 0 [scalar] + sampling rate of the incoming signal + + n_fft : int > 0 [scalar] + number of FFT components + + n_mels : int > 0 [scalar] + number of Mel bands to generate + + fmin : float >= 0 [scalar] + lowest frequency (in Hz) + + fmax : float >= 0 [scalar] + highest frequency (in Hz). + If `None`, use `fmax = sr / 2.0` + + htk : bool [scalar] + use HTK formula instead of Slaney + + Returns + ------- + M : np.ndarray [shape=(n_mels, 1 + n_fft/2)] + Mel transform matrix + + Examples + -------- + >>> melfb = librosa.filters.mel(22050, 2048) + >>> melfb + array([[ 0. , 0.016, ..., 0. , 0. ], + [ 0. , 0. , ..., 0. , 0. ], + ..., + [ 0. , 0. , ..., 0. , 0. ], + [ 0. , 0. , ..., 0. , 0. ]]) + + + Clip the maximum frequency to 8KHz + + >>> librosa.filters.mel(22050, 2048, fmax=8000) + array([[ 0. , 0.02, ..., 0. , 0. ], + [ 0. , 0. , ..., 0. , 0. ], + ..., + [ 0. , 0. , ..., 0. , 0. ], + [ 0. , 0. , ..., 0. , 0. ]]) + + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(melfb, x_axis='linear') + >>> plt.ylabel('Mel filter') + >>> plt.title('Mel filter bank') + >>> plt.colorbar() + >>> plt.tight_layout() + """ + + if fmax is None: + fmax = float(sr) / 2 + + # Initialize the weights + n_mels = int(n_mels) + weights = np.zeros((n_mels, int(1 + n_fft // 2))) + + # Center freqs of each FFT bin + fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft) + + # 'Center freqs' of mel bands - uniformly spaced between limits + freqs = mel_frequencies(n_mels + 2, + fmin=fmin, + fmax=fmax, + htk=htk) + + # Slaney-style mel is scaled to be approx constant energy per channel + enorm = 2.0 / (freqs[2:n_mels+2] - freqs[:n_mels]) + + for i in range(n_mels): + # lower and upper slopes for all bins + lower = (fftfreqs - freqs[i]) / (freqs[i+1] - freqs[i]) + upper = (freqs[i+2] - fftfreqs) / (freqs[i+2] - freqs[i+1]) + + # .. then intersect them with each other and zero + weights[i] = np.maximum(0, np.minimum(lower, upper)) * enorm[i] + + return weights + + +@cache +def chroma(sr, n_fft, n_chroma=12, A440=440.0, ctroct=5.0, + octwidth=2, norm=2, base_c=True): + """Create a Filterbank matrix to convert STFT to chroma + + + Parameters + ---------- + sr : number > 0 [scalar] + audio sampling rate + + n_fft : int > 0 [scalar] + number of FFT bins + + n_chroma : int > 0 [scalar] + number of chroma bins + + A440 : float > 0 [scalar] + Reference frequency for A440 + + ctroct : float > 0 [scalar] + + octwidth : float > 0 or None [scalar] + `ctroct` and `octwidth` specify a dominance window - + a Gaussian weighting centered on `ctroct` (in octs, A0 = 27.5Hz) + and with a gaussian half-width of `octwidth`. + Set `octwidth` to `None` to use a flat weighting. + + norm : float > 0 or np.inf + Normalization factor for each filter + + base_c : bool + If True, the filter bank will start at 'C'. + If False, the filter bank will start at 'A'. + Returns + ------- + wts : ndarray [shape=(n_chroma, 1 + n_fft / 2)] + Chroma filter matrix + + See Also + -------- + util.normalize + feature.chroma_stft + + Examples + -------- + Build a simple chroma filter bank + + >>> chromafb = librosa.filters.chroma(22050, 4096) + array([[ 1.689e-05, 3.024e-04, ..., 4.639e-17, 5.327e-17], + [ 1.716e-05, 2.652e-04, ..., 2.674e-25, 3.176e-25], + ..., + [ 1.578e-05, 3.619e-04, ..., 8.577e-06, 9.205e-06], + [ 1.643e-05, 3.355e-04, ..., 1.474e-10, 1.636e-10]]) + + Use quarter-tones instead of semitones + + >>> librosa.filters.chroma(22050, 4096, n_chroma=24) + array([[ 1.194e-05, 2.138e-04, ..., 6.297e-64, 1.115e-63], + [ 1.206e-05, 2.009e-04, ..., 1.546e-79, 2.929e-79], + ..., + [ 1.162e-05, 2.372e-04, ..., 6.417e-38, 9.923e-38], + [ 1.180e-05, 2.260e-04, ..., 4.697e-50, 7.772e-50]]) + + + Equally weight all octaves + + >>> librosa.filters.chroma(22050, 4096, octwidth=None) + array([[ 3.036e-01, 2.604e-01, ..., 2.445e-16, 2.809e-16], + [ 3.084e-01, 2.283e-01, ..., 1.409e-24, 1.675e-24], + ..., + [ 2.836e-01, 3.116e-01, ..., 4.520e-05, 4.854e-05], + [ 2.953e-01, 2.888e-01, ..., 7.768e-10, 8.629e-10]]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(chromafb, x_axis='linear') + >>> plt.ylabel('Chroma filter') + >>> plt.title('Chroma filter bank') + >>> plt.colorbar() + >>> plt.tight_layout() + """ + + wts = np.zeros((n_chroma, n_fft)) + + # Get the FFT bins, not counting the DC component + frequencies = np.linspace(0, sr, n_fft, endpoint=False)[1:] + + frqbins = n_chroma * hz_to_octs(frequencies, A440) + + # make up a value for the 0 Hz bin = 1.5 octaves below bin 1 + # (so chroma is 50% rotated from bin 1, and bin width is broad) + frqbins = np.concatenate(([frqbins[0] - 1.5 * n_chroma], frqbins)) + + binwidthbins = np.concatenate((np.maximum(frqbins[1:] - frqbins[:-1], + 1.0), [1])) + + D = np.subtract.outer(frqbins, np.arange(0, n_chroma, dtype='d')).T + + n_chroma2 = np.round(float(n_chroma) / 2) + + # Project into range -n_chroma/2 .. n_chroma/2 + # add on fixed offset of 10*n_chroma to ensure all values passed to + # rem are positive + D = np.remainder(D + n_chroma2 + 10*n_chroma, n_chroma) - n_chroma2 + + # Gaussian bumps - 2*D to make them narrower + wts = np.exp(-0.5 * (2*D / np.tile(binwidthbins, (n_chroma, 1)))**2) + + # normalize each column + wts = util.normalize(wts, norm=norm, axis=0) + + # Maybe apply scaling for fft bins + if octwidth is not None: + wts *= np.tile( + np.exp(-0.5 * (((frqbins/n_chroma - ctroct)/octwidth)**2)), + (n_chroma, 1)) + + if base_c: + wts = np.roll(wts, -3, axis=0) + + # remove aliasing columns, copy to ensure row-contiguity + return np.ascontiguousarray(wts[:, :int(1 + n_fft/2)]) + + +@util.decorators.deprecated('0.4', '0.5') +def logfrequency(sr, n_fft, n_bins=84, bins_per_octave=12, tuning=0.0, + fmin=None, spread=0.125): # pragma: no cover + '''Approximate a constant-Q filter bank for a fixed-window STFT. + + Each filter is a log-normal window centered at the corresponding frequency. + + .. warning:: Deprecated in librosa 0.4 + + Parameters + ---------- + sr : number > 0 [scalar] + audio sampling rate + + n_fft : int > 0 [scalar] + FFT window size + + n_bins : int > 0 [scalar] + Number of bins. Defaults to 84 (7 octaves). + + bins_per_octave : int > 0 [scalar] + Number of bins per octave. Defaults to 12 (semitones). + + tuning : None or float in `[-0.5, +0.5]` [scalar] + Tuning correction parameter, in fractions of a bin. + + fmin : float > 0 [scalar] + Minimum frequency bin. Defaults to `C1 ~= 32.70` + + spread : float > 0 [scalar] + Spread of each filter, as a fraction of a bin. + + Returns + ------- + C : np.ndarray [shape=(n_bins, 1 + n_fft/2)] + log-frequency filter bank. + + Examples + -------- + Simple log frequency filters + + >>> logfb = librosa.filters.logfrequency(22050, 4096) + >>> logfb + array([[ 0., 0., ..., 0., 0.], + [ 0., 0., ..., 0., 0.], + ..., + [ 0., 0., ..., 0., 0.], + [ 0., 0., ..., 0., 0.]]) + + + Use a narrower frequency range + + >>> librosa.filters.logfrequency(22050, 4096, n_bins=48, fmin=110) + array([[ 0., 0., ..., 0., 0.], + [ 0., 0., ..., 0., 0.], + ..., + [ 0., 0., ..., 0., 0.], + [ 0., 0., ..., 0., 0.]]) + + + Use narrower filters for sparser response: 5% of a semitone + + >>> librosa.filters.logfrequency(22050, 4096, spread=0.05) + + Or wider: 50% of a semitone + + >>> librosa.filters.logfrequency(22050, 4096, spread=0.5) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(logfb, x_axis='linear') + >>> plt.ylabel('Logarithmic filters') + >>> plt.title('Log-frequency filter bank') + >>> plt.colorbar() + >>> plt.tight_layout() + ''' + + if fmin is None: + fmin = note_to_hz('C1') + + # Apply tuning correction + correction = 2.0**(float(tuning) / bins_per_octave) + + # What's the shape parameter for our log-normal filters? + sigma = float(spread) / bins_per_octave + + # Construct the output matrix + basis = np.zeros((n_bins, int(1 + n_fft/2))) + + # Get log frequencies of bins + log_freqs = np.log2(fft_frequencies(sr, n_fft)[1:]) + + for i in range(n_bins): + # What's the center (median) frequency of this filter? + c_freq = correction * fmin * (2.0**(float(i) / bins_per_octave)) + + # Place a log-normal window around c_freq + basis[i, 1:] = np.exp(-0.5 * ((log_freqs - np.log2(c_freq)) / sigma)**2 + - np.log2(sigma) - log_freqs) + + # Normalize the filters + basis = util.normalize(basis, norm=1, axis=1) + + return basis + + +def __float_window(window_function): + '''Decorator function for windows with fractional input. + + This function guarantees that for fractional `x`, the following hold: + + 1. `__float_window(window_function)(x)` has length `np.ceil(x)` + 2. all values from `np.floor(x)` are set to 0. + + For integer-valued `x`, there should be no change in behavior. + ''' + + def _wrap(n, *args, **kwargs): + '''The wrapped window''' + n_min, n_max = int(np.floor(n)), int(np.ceil(n)) + + window = window_function(n, *args, **kwargs) + + if len(window) < n_max: + window = np.pad(window, [(0, n_max - len(window))], + mode='constant') + + window[n_min:] = 0.0 + + return window + + return _wrap + + +@cache +def constant_q(sr, fmin=None, n_bins=84, bins_per_octave=12, tuning=0.0, + window=None, filter_scale=1, pad_fft=True, norm=1, + resolution=util.Deprecated(), **kwargs): + r'''Construct a constant-Q basis. + + This uses the filter bank described by [1]_. + + .. [1] McVicar, Matthew. + "A machine learning approach to automatic chord extraction." + Dissertation, University of Bristol. 2013. + + + Parameters + ---------- + sr : number > 0 [scalar] + Audio sampling rate + + fmin : float > 0 [scalar] + Minimum frequency bin. Defaults to `C1 ~= 32.70` + + n_bins : int > 0 [scalar] + Number of frequencies. Defaults to 7 octaves (84 bins). + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : float in `[-0.5, +0.5)` [scalar] + Tuning deviation from A440 in fractions of a bin + + window : function or `None` + Windowing function to apply to filters. + Default: `scipy.signal.hann` + + filter_scale : float > 0 [scalar] + Scale of filter windows. + Small values (<1) use shorter windows for higher temporal resolution. + + pad_fft : boolean + Center-pad all filters up to the nearest integral power of 2. + + By default, padding is done with zeros, but this can be overridden + by setting the `mode=` field in *kwargs*. + + norm : {inf, -inf, 0, float > 0} + Type of norm to use for basis function normalization. + See librosa.util.normalize + + kwargs : additional keyword arguments + Arguments to `np.pad()` when `pad==True`. + + resolution : float + .. warning:: This parameter name was in librosa 0.4.2 + Use the `filter_scale` parameter instead. + The `resolution` parameter will be removed in librosa 0.5.0. + + Returns + ------- + filters : np.ndarray, `len(filters) == n_bins` + `filters[i]` is `i`\ th time-domain CQT basis filter + + lengths : np.ndarray, `len(lengths) == n_bins` + The (fractional) length of each filter + + See Also + -------- + constant_q_lengths + librosa.core.cqt + librosa.util.normalize + + + Examples + -------- + Use a shorter window for each filter + + >>> basis, lengths = librosa.filters.constant_q(22050, filter_scale=0.5) + + Plot one octave of filters in time and frequency + + >>> basis, lengths = librosa.filters.constant_q(22050) + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(10, 6)) + >>> plt.subplot(2, 1, 1) + >>> notes = librosa.midi_to_note(np.arange(24, 24 + len(basis))) + >>> for i, (f, n) in enumerate(zip(basis, notes)[:12]): + ... f_scale = librosa.util.normalize(f) / 2 + ... plt.plot(i + f_scale.real) + ... plt.plot(i + f_scale.imag, linestyle=':') + >>> plt.axis('tight') + >>> plt.yticks(range(len(notes[:12])), notes[:12]) + >>> plt.ylabel('CQ filters') + >>> plt.title('CQ filters (one octave, time domain)') + >>> plt.xlabel('Time (samples at 22050 Hz)') + >>> plt.legend(['Real', 'Imaginary'], frameon=True, framealpha=0.8) + >>> plt.subplot(2, 1, 2) + >>> F = np.abs(np.fft.fftn(basis, axes=[-1])) + >>> # Keep only the positive frequencies + >>> F = F[:, :(1 + F.shape[1] // 2)] + >>> librosa.display.specshow(F, x_axis='linear') + >>> plt.yticks(range(len(notes))[::12], notes[::12]) + >>> plt.ylabel('CQ filters') + >>> plt.title('CQ filter magnitudes (frequency domain)') + >>> plt.tight_layout() + ''' + + if fmin is None: + fmin = note_to_hz('C1') + + if window is None: + window = scipy.signal.hann + + filter_scale = util.rename_kw('resolution', resolution, + 'filter_scale', filter_scale, + '0.4.2', '0.5.0') + + # Pass-through parameters to get the filter lengths + lengths = constant_q_lengths(sr, fmin, + n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, + window=window, + filter_scale=filter_scale) + + # Apply tuning correction + correction = 2.0**(float(tuning) / bins_per_octave) + fmin = correction * fmin + + # Q should be capitalized here, so we suppress the name warning + # pylint: disable=invalid-name + Q = float(filter_scale) / (2.0**(1. / bins_per_octave) - 1) + + # Convert lengths back to frequencies + freqs = Q * sr / lengths + + # Build the filters + filters = [] + for ilen, freq in zip(lengths, freqs): + # Build the filter: note, length will be ceil(ilen) + sig = np.exp(np.arange(ilen, dtype=float) * 1j * 2 * np.pi * freq / sr) + + # Apply the windowing function + sig = sig * __float_window(window)(ilen) + + # Normalize + sig = util.normalize(sig, norm=norm) + + filters.append(sig) + + # Pad and stack + max_len = max(lengths) + if pad_fft: + max_len = int(2.0**(np.ceil(np.log2(max_len)))) + else: + max_len = int(np.ceil(max_len)) + + filters = np.asarray([util.pad_center(filt, max_len, **kwargs) + for filt in filters]) + + return filters, np.asarray(lengths) + + +@cache +def constant_q_lengths(sr, fmin, n_bins=84, bins_per_octave=12, + tuning=0.0, window='hann', filter_scale=1, + resolution=util.Deprecated()): + r'''Return length of each filter in a constant-Q basis. + + Parameters + ---------- + sr : number > 0 [scalar] + Audio sampling rate + + fmin : float > 0 [scalar] + Minimum frequency bin. + + n_bins : int > 0 [scalar] + Number of frequencies. Defaults to 7 octaves (84 bins). + + bins_per_octave : int > 0 [scalar] + Number of bins per octave + + tuning : float in `[-0.5, +0.5)` [scalar] + Tuning deviation from A440 in fractions of a bin + + window : str or callable + Window function to use on filters + + filter_scale : float > 0 [scalar] + Resolution of filter windows. Larger values use longer windows. + + resolution : float + .. warning:: This parameter name was in librosa 0.4.2 + Use the `filter_scale` parameter instead. + The `resolution` parameter will be removed in librosa 0.5.0. + + Returns + ------- + lengths : np.ndarray + The length of each filter. + + See Also + -------- + constant_q + librosa.core.cqt + ''' + + filter_scale = util.rename_kw('resolution', resolution, + 'filter_scale', filter_scale, + '0.4.2', '0.5.0') + + if fmin <= 0: + raise ParameterError('fmin must be positive') + + if bins_per_octave <= 0: + raise ParameterError('bins_per_octave must be positive') + + if filter_scale <= 0: + raise ParameterError('filter_scale must be positive') + + if n_bins <= 0 or not isinstance(n_bins, int): + raise ParameterError('n_bins must be a positive integer') + + correction = 2.0**(float(tuning) / bins_per_octave) + + fmin = correction * fmin + + # Q should be capitalized here, so we suppress the name warning + # pylint: disable=invalid-name + Q = float(filter_scale) / (2.0**(1. / bins_per_octave) - 1) + + # Compute the frequencies + freq = fmin * (2.0 ** (np.arange(n_bins, dtype=float) / bins_per_octave)) + + if np.any(freq * (1 + window_bandwidth(window) / Q) > sr / 2.0): + raise ParameterError('Filter pass-band lies beyond Nyquist') + + # Convert frequencies to filter lengths + lengths = Q * sr / freq + + return lengths + + +@cache +def cq_to_chroma(n_input, bins_per_octave=12, n_chroma=12, + fmin=None, window=None, base_c=True): + '''Convert a Constant-Q basis to Chroma. + + + Parameters + ---------- + n_input : int > 0 [scalar] + Number of input components (CQT bins) + + bins_per_octave : int > 0 [scalar] + How many bins per octave in the CQT + + n_chroma : int > 0 [scalar] + Number of output bins (per octave) in the chroma + + fmin : None or float > 0 + Center frequency of the first constant-Q channel. + Default: 'C1' ~= 32.7 Hz + + window : None or np.ndarray + If provided, the cq_to_chroma filter bank will be + convolved with `window`. + + base_c : bool + If True, the first chroma bin will start at 'C' + If False, the first chroma bin will start at 'A' + + Returns + ------- + cq_to_chroma : np.ndarray [shape=(n_chroma, n_input)] + Transformation matrix: `Chroma = np.dot(cq_to_chroma, CQT)` + + Raises + ------ + ParameterError + If `n_input` is not an integer multiple of `n_chroma` + + Examples + -------- + Get a CQT, and wrap bins to chroma + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> CQT = librosa.cqt(y, sr=sr) + >>> chroma_map = librosa.filters.cq_to_chroma(CQT.shape[0]) + >>> chromagram = chroma_map.dot(CQT) + >>> # Max-normalize each time step + >>> chromagram = librosa.util.normalize(chromagram, axis=0) + + >>> import matplotlib.pyplot as plt + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(CQT**2, + ... ref_power=np.max), + ... y_axis='cqt_note', x_axis='time') + >>> plt.title('CQT Power') + >>> plt.colorbar() + >>> plt.subplot(3, 1, 2) + >>> librosa.display.specshow(chromagram, y_axis='chroma', x_axis='time') + >>> plt.title('Chroma (wrapped CQT)') + >>> plt.colorbar() + >>> plt.subplot(3, 1, 3) + >>> chroma = librosa.feature.chromagram(y=y, sr=sr) + >>> librosa.display.specshow(chroma, y_axis='chroma', x_axis='time') + >>> plt.title('librosa.feature.chroma') + >>> plt.colorbar() + >>> plt.tight_layout() + + ''' + + # How many fractional bins are we merging? + n_merge = float(bins_per_octave) / n_chroma + + if fmin is None: + fmin = note_to_hz('C1') + + if np.mod(n_merge, 1) != 0: + raise ParameterError('Incompatible CQ merge: ' + 'input bins must be an ' + 'integer multiple of output bins.') + + # Tile the identity to merge fractional bins + cq_to_ch = np.repeat(np.eye(n_chroma), n_merge, axis=1) + + # Roll it left to center on the target bin + cq_to_ch = np.roll(cq_to_ch, - int(n_merge // 2), axis=1) + + # How many octaves are we repeating? + n_octaves = np.ceil(np.float(n_input) / bins_per_octave) + + # Repeat and trim + cq_to_ch = np.tile(cq_to_ch, int(n_octaves))[:, :n_input] + + # What's the note number of the first bin in the CQT? + # midi uses 12 bins per octave here + midi_0 = np.mod(hz_to_midi(fmin), 12) + + if base_c: + # rotate to C + roll = midi_0 + else: + # rotate to A + roll = midi_0 - 9 + + # Adjust the roll in terms of how many chroma we want out + # We need to be careful with rounding here + roll = int(np.round(roll * (n_chroma / 12.))) + + # Apply the roll + cq_to_ch = np.roll(cq_to_ch, roll, axis=0).astype(float) + + if window is not None: + cq_to_ch = scipy.signal.convolve(cq_to_ch, + np.atleast_2d(window), + mode='same') + + return cq_to_ch + + +def window_bandwidth(window, default=1.0): + '''Get the bandwidth of a window function. + + If the window function is unknown, return a default value. + + Parameters + ---------- + window : callable or string + A window function, or the name of a window function. + Examples: + - scipy.signal.hann + - 'boxcar' + + default : float >= 0 + The default value, if `window` is unknown. + + Returns + ------- + bandwidth : float + The bandwidth of the given window function + + See Also + -------- + scipy.signal.get_window + ''' + + if hasattr(window, '__name__'): + key = window.__name__ + else: + key = window + + if key not in WINDOW_BANDWIDTHS: + warnings.warn("Unknown window function '{:s}'.".format(key)) + + return WINDOW_BANDWIDTHS.get(key, default) diff --git a/librosa/framegenerator.py b/librosa/framegenerator.py deleted file mode 100644 index 9e4981011b..0000000000 --- a/librosa/framegenerator.py +++ /dev/null @@ -1,79 +0,0 @@ -#!/usr/bin/env python -''' -CREATED:2012-10-20 17:09:43 by Brian McFee - -Well-behaved wrapper to audioread - -''' - -import numpy -import audioread - - -## -# Iterate over frames in a raw audio buffer -# -def raw_timeseries(buf, blocksize=512, overlap=0, zero_pad=True): - - n = len(buf) - for i in xrange(0, n, blocksize-overlap): - if i+blocksize < n: - yield buf[i:(i+blocksize)] - elif zero_pad: - z = numpy.zeros((blocksize,)) - z[:(n-i)] = buf[i:(i+blocksize)] - yield z - pass - pass - - -# Example usages: -# -# 1. load all the frames from a wav file -# f = audioread.audio_open('file.wav') -# x = [frame for frame in librosa.framegenerator.audioread_timeseries(f, 512)] -# -# 2. process through AGC -# y = [frame for frame in librosa.tf_agc.tf_agc( librosa.framegenerator.audioread_timeseries(f, 512), -# f.samplerate)] -# - -def audioread_timeseries(audio_blob, blocksize=1024, zero_pad=True, mono=True): - ''' - audio_blob = object returned from audioread.audio_open(...) - blocksize = size of the frames to return (default 512) - zero_pad = if true, last frame is padded out with 0s to blocksize - else, last frame is dropped - mono = if true, and audio_blob is stereo, average channels together first - - iterates over frames and returns - ''' - - if not isinstance(blocksize, int): - raise TypeError('blocksize must be a positive integer') - if blocksize < 0: - raise ValueError('blocksize must be a positive integer') - - if mono and audio_blob.channels > 1: - for frame in audioread_timeseries(audio_blob, blocksize=(2*blocksize), zero_pad=zero_pad, mono=False): - yield (frame[::2] + frame[1::2]) / 2.0 - pass - pass - - # audioread kicks out 16-bit, little-endian PCM - for frame in audio_blob: - - # convert and renormalize buffer from 16-bit, little-endian PCM - # to scaled float - x = numpy.frombuffer(frame, ' - -Harmonic-percussive source separation - -''' - -import numpy, scipy, scipy.signal -import librosa - -def hpss(S, alpha=0.5, max_iter=50): - ''' - Harmonic-percussive source separation - - Ono, N., Miyamoto, K., Kameoka, H., & Sagayama, S. (2008, September). - A real-time equalizer of harmonic and percussive components in music signals. - In Proc. ISMIR (pp. 139-144). - - Input: - S: spectrogram - alpha: balance parameter | default: 0.5 - max_iter: maximum iteration bound | default: 50 - - Output: - H: harmonic component of S - P: percussive component of S - - Note: S = H + P - ''' - # Initialize H/P iterates - H = S * 0.5 - P = H.copy() - - for t in range(max_iter): - # Compute delta - Dh = scipy.signal.convolve2d(H, numpy.array([[0.25, -.5, 0.25]]), mode='same') - Dp = scipy.signal.convolve2d(P, numpy.array([[0.25], [-.5], [0.25]]), mode='same') - D = alpha * Dh - (1-alpha) * Dp - H = numpy.minimum(numpy.maximum(H + D, 0.0), S) - P = S - H - pass - - return (H, P) - -def hpss_median(S, win_P=9, win_H=9, p=0.0): - ''' - Median-filtering harmonic percussive separation - - Fitzgerald, D. (2010). - Harmonic/percussive separation using median filtering. - - Input: - S: spectrogram - win_P: window size for percussive median filtering | default: 7 - win_H: window size for harmonic median filtering | default: 7 - p: masking exponent | default: 0 (hard mask) - ''' - - # Compute median filters - P = scipy.signal.medfilt2d(S, [win_P, 1]) - H = scipy.signal.medfilt2d(S, [1, win_H]) - - if p == 0: - Mh = (H > P).astype(float) - Mp = 1 - Mh - else: - zP = P == 0 - P = P ** p - P[zP] = 0.0 - - zH = H == 0 - H = H ** p - H[zH] = 0.0 - - # Find points where both are zero, equalize - H[zH & zP] = 0.5 - P[zH & zP] = 0.5 - - # Compute harmonic mask - Mh = H / (H + P) - Mp = P / (H + P) - pass - - return (Mh * S, Mp * S) diff --git a/librosa/onset.py b/librosa/onset.py new file mode 100644 index 0000000000..72edfc466e --- /dev/null +++ b/librosa/onset.py @@ -0,0 +1,467 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Onset detection +=============== +.. autosummary:: + :toctree: generated/ + + onset_detect + onset_strength + onset_strength_multi +""" + +import numpy as np +import scipy +import six +import warnings + +from . import cache +from . import core +from . import util +from .util.exceptions import ParameterError + +from .feature.spectral import melspectrogram + +__all__ = ['onset_detect', 'onset_strength', 'onset_strength_multi'] + + +def onset_detect(y=None, sr=22050, onset_envelope=None, hop_length=512, + **kwargs): + """Basic onset detector. Locate note onset events by picking peaks in an + onset strength envelope. + + The `peak_pick` parameters were chosen by large-scale hyper-parameter + optimization over the dataset provided by [1]_. + + .. [1] https://github.com/CPJKU/onset_db + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time series + + sr : number > 0 [scalar] + sampling rate of `y` + + onset_envelope : np.ndarray [shape=(m,)] + (optional) pre-computed onset strength envelope + + hop_length : int > 0 [scalar] + hop length (in samples) + + kwargs : additional keyword arguments + Additional parameters for peak picking. + + See `librosa.util.peak_pick` for details. + + + Returns + ------- + + onsets : np.ndarray [shape=(n_onsets,)] + estimated frame numbers of onsets + + .. note:: + If no onset strength could be detected, onset_detect returns + an empty list. + + + Raises + ------ + ParameterError + if neither `y` nor `onsets` are provided + + + See Also + -------- + onset_strength : compute onset strength per-frame + librosa.util.peak_pick : pick peaks from a time series + + + Examples + -------- + Get onset times from a signal + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... duration=10.0) + >>> onset_frames = librosa.onset.onset_detect(y=y, sr=sr) + >>> librosa.frames_to_time(onset_frames[:20], sr=sr) + array([ 0.07 , 0.279, 0.511, 0.859, 1.091, 1.207, 1.463, + 1.672, 1.904, 2.159, 2.368, 2.601, 2.949, 3.065, + 3.297, 3.529, 3.762, 3.994, 4.203, 4.69 ]) + + + Or use a pre-computed onset envelope + + >>> o_env = librosa.onset.onset_strength(y, sr=sr) + >>> onset_frames = librosa.onset.onset_detect(onset_envelope=o_env, sr=sr) + + + >>> import matplotlib.pyplot as plt + >>> D = np.abs(librosa.stft(y))**2 + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(D, ref_power=np.max), + ... x_axis='time', y_axis='log') + >>> plt.title('Power spectrogram') + >>> plt.subplot(2, 1, 2) + >>> plt.plot(o_env, label='Onset strength') + >>> plt.vlines(onset_frames, 0, o_env.max(), color='r', alpha=0.9, + ... linestyle='--', label='Onsets') + >>> plt.xticks([]) + >>> plt.axis('tight') + >>> plt.legend(frameon=True, framealpha=0.75) + + """ + + # First, get the frame->beat strength profile if we don't already have one + if onset_envelope is None: + if y is None: + raise ParameterError('y or onset_envelope must be provided') + + onset_envelope = onset_strength(y=y, sr=sr, hop_length=hop_length) + + # Shift onset envelope up to be non-negative + # (a common normalization step to make the threshold more consistent) + onset_envelope -= onset_envelope.min() + + # Do we have any onsets to grab? + if not onset_envelope.any(): + return np.array([], dtype=np.int) + + # Normalize onset strength function to [0, 1] range + onset_envelope /= onset_envelope.max() + + # These parameter settings found by large-scale search + kwargs.setdefault('pre_max', 0.03*sr//hop_length) # 30ms + kwargs.setdefault('post_max', 0.00*sr//hop_length + 1) # 0ms + kwargs.setdefault('pre_avg', 0.10*sr//hop_length) # 100ms + kwargs.setdefault('post_avg', 0.10*sr//hop_length + 1) # 100ms + kwargs.setdefault('wait', 0.03*sr//hop_length) # 30ms + kwargs.setdefault('delta', 0.07) + + # Peak pick the onset envelope + return util.peak_pick(onset_envelope, **kwargs) + + +def onset_strength(y=None, sr=22050, S=None, lag=1, max_size=1, + detrend=False, center=True, + feature=None, aggregate=None, + centering=None, + **kwargs): + """Compute a spectral flux onset strength envelope. + + Onset strength at time `t` is determined by: + + `mean_f max(0, S[f, t] - ref_S[f, t - lag])` + + where `ref_S` is `S` after local max filtering along the frequency + axis [1]_. + + By default, if a time series `y` is provided, S will be the + log-power Mel spectrogram. + + .. [1] Böck, Sebastian, and Gerhard Widmer. + "Maximum filter vibrato suppression for onset detection." + 16th International Conference on Digital Audio Effects, + Maynooth, Ireland. 2013. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time-series + + sr : number > 0 [scalar] + sampling rate of `y` + + S : np.ndarray [shape=(d, m)] + pre-computed (log-power) spectrogram + + lag : int > 0 + time lag for computing differences + + max_size : int > 0 + size (in frequency bins) of the local max filter. + set to `1` to disable filtering. + + detrend : bool [scalar] + Filter the onset strength to remove the DC component + + center : bool [scalar] + centering : bool [scalar] (deprecated) + Shift the onset function by `n_fft / (2 * hop_length)` frames + + .. note:: The `centering` parameter is deprecated as of 0.4.1, + and has been replaced by the `center` parameter. + + feature : function + Function for computing time-series features, eg, scaled spectrograms. + By default, uses `librosa.feature.melspectrogram` with `fmax=11025.0` + + aggregate : function + Aggregation function to use when combining onsets + at different frequency bins. + + Default: `np.mean` + + kwargs : additional keyword arguments + Additional parameters to `feature()`, if `S` is not provided. + + + Returns + ------- + onset_envelope : np.ndarray [shape=(m,)] + vector containing the onset strength envelope + + + Raises + ------ + ParameterError + if neither `(y, sr)` nor `S` are provided + + or if `lag` or `max_size` are not positive integers + + + See Also + -------- + onset_detect + onset_strength_multi + + + Examples + -------- + First, load some audio and plot the spectrogram + + >>> import matplotlib.pyplot as plt + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... duration=10.0) + >>> D = np.abs(librosa.stft(y))**2 + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(D, ref_power=np.max), + ... y_axis='log') + >>> plt.title('Power spectrogram') + + Construct a standard onset function + + >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr) + >>> plt.subplot(2, 1, 2) + >>> plt.plot(2 + onset_env / onset_env.max(), alpha=0.8, + ... label='Mean aggregation (mel)') + + + Median aggregation, and custom mel options + + >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr, + ... aggregate=np.median, + ... fmax=8000, n_mels=256) + >>> plt.plot(1 + onset_env / onset_env.max(), alpha=0.8, + ... label='Median aggregation (custom mel)') + + + Constant-Q spectrogram instead of Mel + + >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr, + ... feature=librosa.cqt) + >>> plt.plot(onset_env / onset_env.max(), alpha=0.8, + ... label='Mean aggregation (CQT)') + + >>> plt.legend(frameon=True, framealpha=0.75) + >>> librosa.display.time_ticks(librosa.frames_to_time(np.arange(len(onset_env)))) + >>> plt.ylabel('Normalized strength') + >>> plt.yticks([]) + >>> plt.axis('tight') + >>> plt.tight_layout() + + """ + + if centering is not None: + center = centering + warnings.warn("The 'centering=' parameter of onset_strength is " + "deprecated as of librosa version 0.4.1." + "\n\tIt will be removed in librosa version 0.5.0." + "\n\tPlease use 'center=' instead.", + category=DeprecationWarning) + + odf_all = onset_strength_multi(y=y, + sr=sr, + S=S, + lag=lag, + max_size=max_size, + detrend=detrend, + center=center, + feature=feature, + aggregate=aggregate, + channels=None, + **kwargs) + + return odf_all[0] + + +@cache +def onset_strength_multi(y=None, sr=22050, S=None, lag=1, max_size=1, + detrend=False, center=True, feature=None, + aggregate=None, channels=None, **kwargs): + """Compute a spectral flux onset strength envelope across multiple channels. + + Onset strength for channel `i` at time `t` is determined by: + + `mean_{f in channels[i]} max(0, S[f, t+1] - S[f, t])` + + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + audio time-series + + sr : number > 0 [scalar] + sampling rate of `y` + + S : np.ndarray [shape=(d, m)] + pre-computed (log-power) spectrogram + + lag : int > 0 + time lag for computing differences + + max_size : int > 0 + size (in frequency bins) of the local max filter. + set to `1` to disable filtering. + + detrend : bool [scalar] + Filter the onset strength to remove the DC component + + center : bool [scalar] + Shift the onset function by `n_fft / (2 * hop_length)` frames + + feature : function + Function for computing time-series features, eg, scaled spectrograms. + By default, uses `librosa.feature.melspectrogram` with `fmax=11025.0` + + aggregate : function + Aggregation function to use when combining onsets + at different frequency bins. + + Default: `np.mean` + + channels : list or None + Array of channel boundaries or slice objects. + If `None`, then a single channel is generated to span all bands. + + kwargs : additional keyword arguments + Additional parameters to `feature()`, if `S` is not provided. + + + Returns + ------- + onset_envelope : np.ndarray [shape=(n_channels, m)] + array containing the onset strength envelope for each specified channel. + + + Raises + ------ + ParameterError + if neither `(y, sr)` nor `S` are provided + + + See Also + -------- + onset_strength + + + Examples + -------- + First, load some audio and plot the spectrogram + + >>> import matplotlib.pyplot as plt + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... duration=10.0) + >>> D = np.abs(librosa.stft(y))**2 + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(D, ref_power=np.max), + ... y_axis='log') + >>> plt.title('Power spectrogram') + + Construct a standard onset function over four sub-bands + + >>> onset_subbands = librosa.onset.onset_strength_multi(y=y, sr=sr, + ... channels=[0, 32, 64, 96, 128]) + >>> plt.subplot(2, 1, 2) + >>> librosa.display.specshow(onset_subbands, x_axis='time') + >>> plt.title('Sub-band onset strength') + + """ + + if feature is None: + feature = melspectrogram + kwargs.setdefault('fmax', 11025.0) + + if aggregate is None: + aggregate = np.mean + + if lag < 1 or not isinstance(lag, int): + raise ParameterError('lag must be a positive integer') + + if max_size < 1 or not isinstance(max_size, int): + raise ParameterError('max_size must be a positive integer') + + # First, compute mel spectrogram + if S is None: + S = np.abs(feature(y=y, sr=sr, **kwargs)) + + # Convert to dBs + S = core.logamplitude(S) + + # Retrieve the n_fft and hop_length, + # or default values for onsets if not provided + n_fft = kwargs.get('n_fft', 2048) + hop_length = kwargs.get('hop_length', 512) + + # Ensure that S is at least 2-d + S = np.atleast_2d(S) + + # Compute the reference spectrogram. + # Efficiency hack: skip filtering step and pass by reference + # if max_size will produce a no-op. + if max_size == 1: + ref_spec = S + else: + ref_spec = scipy.ndimage.maximum_filter1d(S, max_size, axis=0) + + # Compute difference to the reference, spaced by lag + onset_env = S[:, lag:] - ref_spec[:, :-lag] + + # Discard negatives (decreasing amplitude) + onset_env = np.maximum(0.0, onset_env) + + # Aggregate within channels + pad = True + if channels is None: + channels = [slice(None)] + else: + pad = False + + onset_env = util.sync(onset_env, channels, + aggregate=aggregate, + pad=pad, + axis=0) + + # compensate for lag + pad_width = lag + if center: + # Counter-act framing effects. Shift the onsets by n_fft / hop_length + pad_width += n_fft // (2 * hop_length) + + onset_env = np.pad(onset_env, ([0, 0], [int(pad_width), 0]), mode='constant') + + # remove the DC component + if detrend: + onset_env = scipy.signal.lfilter([1.0, -1.0], [1.0, -0.99], onset_env, axis=-1) + + # Trim to match the input duration + if center: + onset_env = onset_env[:, :S.shape[1]] + + return onset_env diff --git a/librosa/output.py b/librosa/output.py index 1f578b4752..52a44bb2ba 100644 --- a/librosa/output.py +++ b/librosa/output.py @@ -1,36 +1,288 @@ #!/usr/bin/env python -''' -CREATED:2013-01-23 09:26:25 by Brian McFee +# -*- coding: utf-8 -*- +""" +Output +====== -Utility functions for analysis output, eg: +Text output +----------- +.. autosummary:: + :toctree: generated/ - - sonic visualizer output for clustering/beat tracking - - ??? + annotation + times_csv -''' +Audio output +------------ +.. autosummary:: + :toctree: generated/ + + write_wav + +Deprecated +---------- +.. autosummary:: + :toctree: generated/ + + frames_csv + +""" -import librosa -import numpy, scipy import csv -def segment_csv(outfile, segments, sr, hop_length): - ''' - Save beat tracker or segmentation output in CSV format +import numpy as np +import scipy +import scipy.io.wavfile + +from . import core +from . import util +from .util.exceptions import ParameterError + + +__all__ = ['annotation', 'times_csv', 'write_wav', + # Deprecated functions + 'frames_csv'] + + +def annotation(path, intervals, annotations=None, delimiter=',', fmt='%0.3f'): + r'''Save annotations in a 3-column format:: + + intervals[0, 0],intervals[0, 1],annotations[0]\n + intervals[1, 0],intervals[1, 1],annotations[1]\n + intervals[2, 0],intervals[2, 1],annotations[2]\n + ... + + This can be used for segment or chord annotations. + + Parameters + ---------- + path : str + path to save the output CSV file + + intervals : np.ndarray [shape=(n, 2)] + array of interval start and end-times. + - `intervals[i, 0]` marks the start time of interval `i` + - `intervals[i, 1]` marks the endtime of interval `i` + + annotations : None or list-like [shape=(n,)] + optional list of annotation strings. `annotations[i]` applies + to the time range `intervals[i, 0]` to `intervals[i, 1]` + + delimiter : str + character to separate fields + + fmt : str + format-string for rendering time data + + Raises + ------ + ParameterError + if `annotations` is not `None` and length does + not match `intervals` + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> data = librosa.feature.mfcc(y=y, sr=sr, hop_length=512) + + Detect segment boundaries + + >>> boundaries = librosa.segment.agglomerative(data, k=10) + + Convert to time + + >>> boundary_times = librosa.frames_to_time(boundaries, sr=sr, + ... hop_length=512) + + Convert events boundaries to intervals + + >>> intervals = np.hstack([boundary_times[:-1, np.newaxis], + ... boundary_times[1:, np.newaxis]]) + + Make some fake annotations + + >>> labels = ['Seg #{:03d}'.format(i) for i in range(len(intervals))] + + Save the output + + >>> librosa.output.annotation('segments.csv', intervals, + ... annotations=labels) - Input: - outfile: path to the output file - segments: 1-by-n list of frame numbers for beat events - sr: sample rate of the beat detector (eg 8000) - hop_length: hop length of the beat detector (32) ''' - with open(outfile, 'w') as f: - CW = csv.writer(f) + util.valid_intervals(intervals) + + if annotations is not None and len(annotations) != len(intervals): + raise ParameterError('len(annotations) != len(intervals)') + + with open(path, 'w') as output_file: + writer = csv.writer(output_file, delimiter=delimiter) + + if annotations is None: + for t_int in intervals: + writer.writerow([fmt % t_int[0], fmt % t_int[1]]) + else: + for t_int, lab in zip(intervals, annotations): + writer.writerow([fmt % t_int[0], fmt % t_int[1], lab]) + + +def times_csv(path, times, annotations=None, delimiter=',', fmt='%0.3f'): + r"""Save time steps as in CSV format. This can be used to store the output + of a beat-tracker or segmentation algorihtm. + + If only `times` are provided, the file will contain each value + of `times` on a row:: + + times[0]\n + times[1]\n + times[2]\n + ... + + If `annotations` are also provided, the file will contain + delimiter-separated values:: + + times[0],annotations[0]\n + times[1],annotations[1]\n + times[2],annotations[2]\n + ... + + + Parameters + ---------- + path : string + path to save the output CSV file + + times : list-like of floats + list of frame numbers for beat events + + annotations : None or list-like + optional annotations for each time step + + delimiter : str + character to separate fields + + fmt : str + format-string for rendering time + + Raises + ------ + ParameterError + if `annotations` is not `None` and length does not + match `times` + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y, sr=sr) + >>> times = librosa.frames_to_time(beats, sr=sr) + >>> librosa.output.times_csv('beat_times.csv', times) + """ + + if annotations is not None and len(annotations) != len(times): + raise ParameterError('len(annotations) != len(times)') + + with open(path, 'w') as output_file: + writer = csv.writer(output_file, delimiter=delimiter) + + if annotations is None: + for t in times: + writer.writerow([fmt % t]) + else: + for t, lab in zip(times, annotations): + writer.writerow([(fmt % t), lab]) + + +def write_wav(path, y, sr, norm=True): + """Output a time series as a .wav file + + Parameters + ---------- + path : str + path to save the output wav file + + y : np.ndarray [shape=(n,) or (2,n)] + audio time series (mono or stereo) + + sr : int > 0 [scalar] + sampling rate of `y` + + norm : boolean [scalar] + enable amplitude normalization + + Examples + -------- + Trim a signal to 5 seconds and save it back + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), + ... duration=5.0) + >>> librosa.output.write_wav('file_trim_5s.wav', y, sr) + + """ + + # Validate the buffer. Stereo is okay here. + util.valid_audio(y, mono=False) + + # normalize + if norm: + wav = util.normalize(y, norm=np.inf, axis=None) + else: + wav = y + + # Check for stereo + if wav.ndim > 1 and wav.shape[0] == 2: + wav = wav.T + + # Save + scipy.io.wavfile.write(path, sr, wav) + + +# Deprecated functions below + +@util.decorators.deprecated('0.4', '0.5') +def frames_csv(path, frames, sr=22050, hop_length=512, + n_fft=None, **kwargs): # pragma: no cover + """Convert frames to time and store the output in CSV format. + + .. warning:: Deprecated in librosa 0.4 + Functionality is redundant with `times_csv` + + + Parameters + ---------- + path : string + path to save the output CSV file + + frames : list-like of ints + list of frame numbers for beat events + + sr : number > 0 [scalar] + audio sampling rate + + hop_length : int > 0 [scalar] + number of samples between success frames + + n_fft : None or int > 0 + length of the FFT window, if using left-aligned frames. + If specified, the output `time[i]` will correspond to the + center of the frame starting at `frames[i] * hop_length` + samples. + + kwargs : additional keyword arguments + Arguments passed through to `times_csv` + + See Also + -------- + times_csv + librosa.core.frames_to_time + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y, sr=sr) + >>> librosa.output.frames_csv('beat_times.csv', beats, sr=sr) + """ + + times = core.frames_to_time(frames, sr=sr, hop_length=hop_length, + n_fft=n_fft) - t = 0.0 - for t_new in librosa.frames_to_time(segments, sr=sr, hop_length=hop_length): - CW.writerow([t_new, '%.2f BPM' % (60.0 / (t_new - t))]) - t = t_new - pass - pass - pass + times_csv(path, times, **kwargs) diff --git a/librosa/segment.py b/librosa/segment.py new file mode 100644 index 0000000000..3d756cf11b --- /dev/null +++ b/librosa/segment.py @@ -0,0 +1,691 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Temporal segmentation +===================== + +Recurrence and self-similarity +------------------------------ +.. autosummary:: + :toctree: generated/ + + recurrence_matrix + recurrence_to_lag + lag_to_recurrence + timelag_filter + +Temporal clustering +------------------- +.. autosummary:: + :toctree: generated/ + + agglomerative + subsegment + +Deprecated +---------- +.. autosummary:: + :toctree: generated/ + + structure_feature +""" + +from decorator import decorator + +import numpy as np +import scipy +import scipy.signal + +import sklearn +import sklearn.cluster +import sklearn.feature_extraction + +from . import cache +from . import util +from .util.exceptions import ParameterError + +__all__ = ['recurrence_matrix', + 'recurrence_to_lag', + 'lag_to_recurrence', + 'timelag_filter', + 'agglomerative', + 'subsegment', + # Deprecated functions + 'structure_feature'] + + +@cache +def __band_infinite(n, width, v_in=0.0, v_out=np.inf, dtype=np.float32): + '''Construct a square, banded matrix `X` where + `X[i, j] == v_in` if `|i - j| <= width` + `X[i, j] == v_out` if `|i - j| > width` + + This is used to suppress nearby links in `recurrence_matrix`. + ''' + + if width > n: + raise ParameterError('width cannot exceed n') + + # Instantiate the matrix + band = np.empty((n, n), dtype=dtype) + + # Fill the out-of-band values + band.fill(v_out) + + # Fill the in-band values + band[np.triu_indices_from(band, width)] = v_in + band[np.tril_indices_from(band, -width)] = v_in + + return band + + +@cache +def recurrence_matrix(data, k=None, width=1, metric='sqeuclidean', + sym=False, axis=-1): + '''Compute the binary recurrence matrix from a time-series. + + `rec[i,j] == True` if (and only if) (`data[:,i]`, `data[:,j]`) are + k-nearest-neighbors and `|i-j| >= width` + + + Parameters + ---------- + data : np.ndarray + A feature matrix + + k : int > 0 [scalar] or None + the number of nearest-neighbors for each sample + + Default: `k = 2 * ceil(sqrt(t - 2 * width + 1))`, + or `k = 2` if `t <= 2 * width + 1` + + width : int >= 1 [scalar] + only link neighbors `(data[:, i], data[:, j])` + if `|i-j| >= width` + + metric : str + Distance metric to use for nearest-neighbor calculation. + + See `scipy.spatial.distance.cdist` for details. + + sym : bool [scalar] + set `sym=True` to only link mutual nearest-neighbors + + axis : int + The axis along which to compute recurrence. + By default, the last index (-1) is taken. + + Returns + ------- + rec : np.ndarray [shape=(t,t), dtype=bool] + Binary recurrence matrix + + See Also + -------- + scipy.spatial.distance.cdist + librosa.feature.stack_memory + structure_feature + + Examples + -------- + Find nearest neighbors in MFCC space + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfcc = librosa.feature.mfcc(y=y, sr=sr) + >>> R = librosa.segment.recurrence_matrix(mfcc) + + Or fix the number of nearest neighbors to 5 + + >>> R = librosa.segment.recurrence_matrix(mfcc, k=5) + + Suppress neighbors within +- 7 samples + + >>> R = librosa.segment.recurrence_matrix(mfcc, width=7) + + Use cosine similarity instead of Euclidean distance + + >>> R = librosa.segment.recurrence_matrix(mfcc, metric='cosine') + + Require mutual nearest neighbors + + >>> R = librosa.segment.recurrence_matrix(mfcc, sym=True) + + Plot the feature and recurrence matrices + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(10, 6)) + >>> plt.subplot(1, 2, 1) + >>> librosa.display.specshow(mfcc, x_axis='time') + >>> plt.title('MFCC') + >>> plt.subplot(1, 2, 2) + >>> librosa.display.specshow(R, x_axis='time', y_axis='time', + ... aspect='equal') + >>> plt.title('MFCC recurrence (symmetric)') + >>> plt.tight_layout() + + ''' + + data = np.atleast_2d(data) + + # Swap observations to the first dimension and flatten the rest + data = np.swapaxes(data, axis, 0) + t = data.shape[0] + data = data.reshape((t, -1)) + + if width < 1: + raise ParameterError('width must be at least 1') + + if k is None: + if t > 2 * width + 1: + k = 2 * np.ceil(np.sqrt(t - 2 * width + 1)) + else: + k = 2 + + k = int(k) + + # Build the distance matrix + D = scipy.spatial.distance.cdist(data, data, metric=metric) + + # Max out the diagonal band + D = D + __band_infinite(t, width) + + # build the recurrence plot + rec = np.zeros((t, t), dtype=bool) + + # get the k nearest neighbors for each point + for i in range(t): + for j in np.argsort(D[i])[:k]: + rec[i, j] = True + + # symmetrize + if sym: + rec = rec * rec.T + + return rec + + +def recurrence_to_lag(rec, pad=True, axis=-1): + '''Convert a recurrence matrix into a lag matrix. + + `lag[i, j] == rec[i+j, j]` + + Parameters + ---------- + rec : np.ndarray, [shape=(n, n)] + A (binary) recurrence matrix, as returned by `recurrence_matrix` + + pad : bool + If False, `lag` matrix is square, which is equivalent to + assuming that the signal repeats itself indefinitely. + + If True, `lag` is padded with `n` zeros, which eliminates + the assumption of repetition. + + axis : int + The axis along which to apply the recurrence-to-lag conversion + + Returns + ------- + lag : np.ndarray [shape=(2*n, n) or (n, n)] + The recurrence matrix in (lag, time) coordinates + + Raises + ------ + ParameterError : if `rec` is non-square + + See Also + -------- + recurrence_matrix + lag_to_recurrence + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfccs = librosa.feature.mfcc(y=y, sr=sr) + >>> recurrence = librosa.segment.recurrence_matrix(mfccs) + >>> lag_pad = librosa.segment.recurrence_to_lag(recurrence, pad=True) + >>> lag_nopad = librosa.segment.recurrence_to_lag(recurrence, pad=False) + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(8, 4)) + >>> plt.subplot(1, 2, 1) + >>> librosa.display.specshow(lag_pad, x_axis='time', y_axis='lag') + >>> plt.title('Lag (zero-padded)') + >>> plt.subplot(1, 2, 2) + >>> librosa.display.specshow(lag_nopad, x_axis='time', y_axis='time') + >>> plt.title('Lag (no padding)') + >>> plt.tight_layout() + ''' + + axis = np.abs(axis) + + if rec.ndim != 2 or rec.shape[0] != rec.shape[1]: + raise ParameterError('non-square recurrence matrix shape: ' + '{}'.format(rec.shape)) + + t = rec.shape[axis] + + if pad: + padding = [(0, 0), (0, 0)] + padding[(1-axis)] = (0, t) + lag = np.pad(rec, padding, mode='constant') + else: + lag = rec.copy() + + idx_slice = [slice(None)] * lag.ndim + for i in range(1, t): + idx_slice[axis] = i + lag[idx_slice] = np.roll(lag[idx_slice], -i) + + return np.ascontiguousarray(lag.T).T + + +def lag_to_recurrence(lag, axis=-1): + '''Convert a lag matrix into a recurrence matrix. + + Parameters + ---------- + lag : np.ndarray [shape=(2*n, n) or (n, n)] + A lag matrix, as produced by `recurrence_to_lag` + + axis : int + The axis along which to apply the recurrence-to-lag conversion + + Returns + ------- + rec : np.ndarray [shape=(n, n)] + A recurrence matrix in (time, time) coordinates + + Raises + ------ + ParameterError : if `lag` does not have the correct shape + + See Also + -------- + recurrence_to_lag + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfccs = librosa.feature.mfcc(y=y, sr=sr) + >>> recurrence = librosa.segment.recurrence_matrix(mfccs) + >>> lag_pad = librosa.segment.recurrence_to_lag(recurrence, pad=True) + >>> lag_nopad = librosa.segment.recurrence_to_lag(recurrence, pad=False) + >>> rec_pad = librosa.segment.lag_to_recurrence(lag_pad) + >>> rec_nopad = librosa.segment.lag_to_recurrence(lag_nopad) + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(8, 4)) + >>> plt.subplot(2, 2, 1) + >>> librosa.display.specshow(lag_pad, x_axis='time', y_axis='lag') + >>> plt.title('Lag (zero-padded)') + >>> plt.subplot(2, 2, 2) + >>> librosa.display.specshow(lag_nopad, x_axis='time', y_axis='time') + >>> plt.title('Lag (no padding)') + >>> plt.subplot(2, 2, 3) + >>> librosa.display.specshow(rec_pad, x_axis='time', y_axis='time') + >>> plt.title('Recurrence (with padding)') + >>> plt.subplot(2, 2, 4) + >>> librosa.display.specshow(rec_nopad, x_axis='time', y_axis='time') + >>> plt.title('Recurrence (without padding)') + >>> plt.tight_layout() + + ''' + + axis = np.abs(axis) + + if lag.ndim != 2 or (lag.shape[0] != lag.shape[1] and + lag.shape[1 - axis] != 2 * lag.shape[axis]): + raise ParameterError('Invalid lag matrix shape: {}'.format(lag.shape)) + + # Since lag must be 2-dimensional, abs(axis) = axis + t = lag.shape[axis] + lag = lag.copy() + + idx_slice = [slice(None)] * lag.ndim + for i in range(1, t): + idx_slice[axis] = i + lag[idx_slice] = np.roll(lag[idx_slice], i) + + sub_slice = [slice(None)] * lag.ndim + sub_slice[1 - axis] = slice(t) + return np.ascontiguousarray(lag[sub_slice].T).T + + +def timelag_filter(function, pad=True, index=0): + '''Filtering in the time-lag domain. + + This is primarily useful for adapting image filters to operate on + `structure_feature` output. + + Using `timelag_filter` is equivalent to the following sequence of + operations: + + >>> data_tl = librosa.segment.recurrence_to_lag(data) + >>> data_filtered_tl = function(data_tl) + >>> data_filtered = librosa.segment.lag_to_recurrence(data_filtered_tl) + + Parameters + ---------- + function : callable + The filtering function to wrap, e.g., `scipy.ndimage.median_filter` + + pad : bool + Whether to zero-pad the structure feature matrix + + index : int >= 0 + If `function` accepts input data as a positional argument, it should be + indexed by `index` + + + Returns + ------- + wrapped_function : callable + A new filter function which applies in time-lag space rather than + time-time space. + + + See Also + -------- + structure_feature + + + Examples + -------- + + Apply a 5-bin median filter to the diagonal of a recurrence matrix + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfcc = librosa.feature.mfcc(y=y, sr=sr) + >>> rec = librosa.segment.recurrence_matrix(mfcc, sym=True) + >>> from scipy.ndimage import median_filter + >>> diagonal_median = librosa.segment.timelag_filter(median_filter) + >>> rec_filtered = diagonal_median(rec, size=(1, 5), mode='mirror') + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(1, 2, 1) + >>> librosa.display.specshow(rec, x_axis='time', y_axis='time', + ... aspect='equal') + >>> plt.title('Raw recurrence matrix') + >>> plt.subplot(1, 2, 2) + >>> librosa.display.specshow(rec_filtered, x_axis='time', y_axis='time', + ... aspect='equal') + >>> plt.title('Filtered recurrence matrix') + >>> plt.tight_layout() + ''' + + @cache + def __my_filter(wrapped_f, *args, **kwargs): + '''Decorator to wrap the filter''' + # Map the input data into time-lag space + args = list(args) + + args[index] = recurrence_to_lag(args[index], pad=pad) + + # Apply the filtering function + result = wrapped_f(*args, **kwargs) + + # Map back into time-time and return + return lag_to_recurrence(result) + + return decorator(__my_filter, function) + + +@cache +def subsegment(data, frames, n_segments=4, axis=-1): + '''Sub-divide a segmentation by feature clustering. + + Given a set of frame boundaries (`frames`), and a data matrix (`data`), + each successive interval defined by `frames` is partitioned into + `n_segments` by constrained agglomerative clustering. + + .. note:: + If an interval spans fewer than `n_segments` frames, then each + frame becomes a sub-segment. + + Parameters + ---------- + data : np.ndarray + Data matrix to use in clustering + + frames : np.ndarray [shape=(n_boundaries,)], dtype=int, non-negative] + Array of beat or segment boundaries, as provided by + `librosa.beat.beat_track`, + `librosa.onset.onset_detect`, + or `agglomerative`. + + n_segments : int > 0 + Maximum number of frames to sub-divide each interval. + + axis : int + Axis along which to apply the segmentation. + By default, the last index (-1) is taken. + + Returns + ------- + boundaries : np.ndarray [shape=(n_subboundaries,)] + List of sub-divided segment boundaries + + See Also + -------- + agglomerative : Temporal segmentation + librosa.onset.onset_detect : Onset detection + librosa.beat.beat_track : Beat tracking + + Examples + -------- + Load audio, detect beat frames, and subdivide in twos by CQT + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15) + >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr, hop_length=512) + >>> cqt = librosa.cqt(y, sr=sr, hop_length=512) + >>> subseg = librosa.segment.subsegment(cqt, beats, n_segments=2) + >>> subseg + array([ 0, 2, 4, 21, 23, 26, 43, 55, 63, 72, 83, + 97, 102, 111, 122, 137, 142, 153, 162, 180, 182, 185, + 202, 210, 221, 231, 241, 256, 261, 271, 281, 296, 301, + 310, 320, 339, 341, 344, 361, 368, 382, 389, 401, 416, + 420, 430, 436, 451, 456, 465, 476, 489, 496, 503, 515, + 527, 535, 544, 553, 558, 571, 578, 590, 607, 609, 638]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> librosa.display.specshow(librosa.logamplitude(cqt**2, + ... ref_power=np.max), + ... y_axis='cqt_hz', x_axis='time') + >>> plt.vlines(beats, 0, cqt.shape[0], color='r', alpha=0.5, + ... label='Beats') + >>> plt.vlines(subseg, 0, cqt.shape[0], color='b', linestyle='--', + ... alpha=0.5, label='Sub-beats') + >>> plt.legend(frameon=True, shadow=True) + >>> plt.title('CQT + Beat and sub-beat markers') + >>> plt.tight_layout() + + ''' + + frames = util.fix_frames(frames, x_min=0, x_max=data.shape[axis], pad=True) + + if n_segments < 1: + raise ParameterError('n_segments must be a positive integer') + + boundaries = [] + idx_slices = [slice(None)] * data.ndim + + for seg_start, seg_end in zip(frames[:-1], frames[1:]): + idx_slices[axis] = slice(seg_start, seg_end) + boundaries.extend(seg_start + agglomerative(data[idx_slices], + min(seg_end - seg_start, n_segments), + axis=axis)) + + return np.ascontiguousarray(boundaries) + + +def agglomerative(data, k, clusterer=None, axis=-1): + """Bottom-up temporal segmentation. + + Use a temporally-constrained agglomerative clustering routine to partition + `data` into `k` contiguous segments. + + Parameters + ---------- + data : np.ndarray + data to cluster + + k : int > 0 [scalar] + number of segments to produce + + clusterer : sklearn.cluster.AgglomerativeClustering, optional + An optional AgglomerativeClustering object. + If `None`, a constrained Ward object is instantiated. + + axis : int + axis along which to cluster. + By default, the last axis (-1) is chosen. + + Returns + ------- + boundaries : np.ndarray [shape=(k,)] + left-boundaries (frame numbers) of detected segments. This + will always include `0` as the first left-boundary. + + See Also + -------- + sklearn.cluster.AgglomerativeClustering + + Examples + -------- + Cluster by chroma similarity, break into 20 segments + + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15) + >>> chroma = librosa.feature.chroma_cqt(y=y, sr=sr) + >>> boundary_frames = librosa.segment.agglomerative(chroma, 20) + >>> librosa.frames_to_time(boundary_frames, sr=sr) + array([ 0. , 1.672, 2.322, 2.624, 3.251, 3.506, + 4.18 , 5.387, 6.014, 6.293, 6.943, 7.198, + 7.848, 9.033, 9.706, 9.961, 10.635, 10.89 , + 11.54 , 12.539]) + + Plot the segmentation against the spectrogram + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> S = np.abs(librosa.stft(y))**2 + >>> librosa.display.specshow(librosa.logamplitude(S, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.vlines(boundary_frames, 0, S.shape[0], color='r', alpha=0.9, + ... label='Segment boundaries') + >>> plt.legend(frameon=True, shadow=True) + >>> plt.title('Power spectrogram') + >>> plt.tight_layout() + + """ + + # Make sure we have at least two dimensions + data = np.atleast_2d(data) + + # Swap data index to position 0 + data = np.swapaxes(data, axis, 0) + + # Flatten the features + n = data.shape[0] + data = data.reshape((n, -1)) + + if clusterer is None: + # Connect the temporal connectivity graph + grid = sklearn.feature_extraction.image.grid_to_graph(n_x=n, + n_y=1, n_z=1) + + # Instantiate the clustering object + clusterer = sklearn.cluster.AgglomerativeClustering(n_clusters=k, + connectivity=grid, + memory=cache) + + # Fit the model + clusterer.fit(data) + + # Find the change points from the labels + boundaries = [0] + boundaries.extend( + list(1 + np.nonzero(np.diff(clusterer.labels_))[0].astype(int))) + return np.asarray(boundaries) + + +# Deprecated functions + +@util.decorators.deprecated('0.4', '0.5') +@cache +def structure_feature(rec, pad=True, inverse=False): + '''Compute the structure feature from a recurrence matrix. + + The i'th column of the recurrence matrix is shifted up by i. + The resulting matrix is indexed horizontally by time, + and vertically by lag. + + .. warning:: Deprected in librosa 0.4 + Functionality is superseded by + `librosa.segment.recurrence_to_lag` and + `librosa.segment.lag_to_recurrence`. + + Parameters + ---------- + rec : np.ndarray [shape=(t,t) or shape=(2*t, t)] + recurrence matrix or pre-computed structure feature + + pad : bool [scalar] + Pad the matrix with `t` rows of zeros to avoid looping. + + inverse : bool [scalar] + Unroll the opposite direction. This is useful for converting + structure features back into recurrence plots. + + .. note: Reversing with `pad==True` will truncate the + inferred padding. + + Returns + ------- + struct : np.ndarray [shape=(2*t, t) or shape=(t, t)] + `struct[i, t]` = the recurrence at time `t` with lag `i`. + + .. note:: negative lag values are supported by wrapping to the + end of the array. + + See Also + -------- + recurrence_matrix : build a recurrence matrix from feature vectors + + Examples + -------- + Build the structure feature over mfcc similarity + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> mfccs = librosa.feature.mfcc(y=y, sr=sr) + >>> recurrence = librosa.segment.recurrence_matrix(mfccs) + >>> struct = librosa.segment.structure_feature(recurrence) + + + Invert the structure feature to get a recurrence matrix + + >>> recurrence_2 = librosa.segment.structure_feature(struct, + ... inverse=True) + + Display recurrence in time-time and time-lag space + + >>> import matplotlib.pyplot as plt + >>> plt.figure(figsize=(10, 5)) + >>> plt.subplot(1, 2, 1) + >>> librosa.display.specshow(recurrence, aspect='equal', x_axis='time', + ... y_axis='time') + >>> plt.ylabel('Time') + >>> plt.title('Recurrence (time-time)') + >>> plt.subplot(1, 2, 2) + >>> librosa.display.specshow(struct, aspect='auto', x_axis='time') + >>> plt.ylabel('Lag') + >>> plt.title('Structure feature') + >>> plt.tight_layout() + + ''' + if inverse: + return lag_to_recurrence(rec) + else: + return recurrence_to_lag(rec, pad=pad) diff --git a/librosa/tf_agc.py b/librosa/tf_agc.py deleted file mode 100644 index 9580bd534d..0000000000 --- a/librosa/tf_agc.py +++ /dev/null @@ -1,125 +0,0 @@ -#!/usr/bin/env python -''' -CREATED:2012-10-20 12:20:33 by Brian McFee - -Time-frequency automatic gain control - -Ported from tf_agc.m by DPWE - http://www.ee.columbia.edu/~dpwe/resources/matlab/tf_agc/ -''' - -import numpy -import scipy -import librosa - -def tf_agc(frame_iterator, sample_rate=22050, **kwargs): - ''' - frame_iterator librosa.framegenerator - sample_rate sampling rate of the audio stream - - Optional arguments: - frequency_scale (f_scale from dpwe) (default: 1.0) - alpha (default: 0.95 ) - gaussian_smoothing (type) (default: False) - Use time-symmetric, non-causal Gaussian window smoothing XXX: not supported - Otherwise, defaults to infinite-attack, exponential release - ''' - - ## - # Parse arguments - frequency_scale = 1.0 - if 'frequency_scale' in kwargs: - frequency_scale = kwargs['frequency_scale'] - if not isinstance(frequency_scale, float): - raise TypeError('Argument frequency_scale must be of type float') - if frequency_scale <= 0.0: - raise ValueError('Argument frequency_scale must be a non-negative float') - pass - - - alpha = 0.95 - if 'alpha' in kwargs: - alpha = kwargs['alpha'] - if not isinstance(alpha, float): - raise TypeError('Argument alpha must be of type float') - if not (0.0 < alpha < 1.0): - raise ValueError('Argument alpha must be between 0.0 and 1.0') - pass - - gaussian_smoothing = False - if 'gaussian_smoothing' in kwargs: - gaussian_smoothing = kwargs['gaussian_smoothing'] - if not isinstance(gaussian_smoothing, bool): - raise TypeError('Argument gaussian_smoothing must be of type bool') - if gaussian_smoothing: - raise ValueError('Gaussian smoothing currently unsupported') - pass - - - # Setup - - # How many frequency bands do we need? - num_frequency_bands = max(10, int(20 / frequency_scale)) - mel_filter_width = int(frequency_scale * num_frequency_bands / 10); - - # initialize the mel filterbank to None; - # do the real initialization after grabbing the first frame - f2a = None - - if gaussian_smoothing: - pass - else: - # Else, use infinite-attack exp-release - - - # Iterate over frames - for frame in frame_iterator: - - if f2a is None: - # initialize the mel filter bank after grabbing the first frame - - f2a = librosa.melfb(sample_rate, len(frame), num_frequency_bands, mel_filter_width) - f2a = f2a[:,:(round(len(frame)/2) + 1)] - - #% map back to FFT grid, flatten bark loop gain - #sf2a = sum(f2a); - - normalize_f2a = numpy.zeros( (f2a.shape[1], 1) ) - normalize_f2a[:,0] = numpy.sum(f2a, axis=0) - normalize_f2a[normalize_f2a == 0] = 1.0 - normalize_f2a = 1.0 / normalize_f2a - - # initialze the state vector - state = numpy.zeros( (num_frequency_bands, 1) ) - - pass - - # FFT each frame -# D = scipy.fft(frame) - D = librosa.stft(frame, n_fft=len(frame)) - # multiply by f2a - audiogram = numpy.dot(f2a, numpy.abs(D)) - - ## DPWE - # state = max([alpha*state,audgram(:,i)],[],2); - # fbg(:,i) = state; - # ... - # - state = numpy.maximum(alpha * state, audiogram) - - #E = diag(1./(sf2a+(sf2a==0))) * f2a' * fbg; - E = normalize_f2a * (numpy.dot(f2a.T, state)); - - - #% Remove any zeros in E (shouldn't be any, but who knows?) - #E(E(:)<=0) = min(E(E(:)>0)); - E[E<=0.0] = min(E[E>0.0]) - - #% invert back to waveform - y = librosa.istft(D/E); -# y = numpy.real(scipy.ifft(D/E)) - - yield y - pass - - pass diff --git a/librosa/util/__init__.py b/librosa/util/__init__.py new file mode 100644 index 0000000000..fce598cb79 --- /dev/null +++ b/librosa/util/__init__.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Utilities +========= + +Array operations +---------------- +.. autosummary:: + :toctree: generated/ + + frame + pad_center + fix_length + fix_frames + index_to_slice + sync + + axis_sort + normalize + sparsify_rows + + buf_to_float + + +Matching +-------- +.. autosummary:: + :toctree: generated/ + + match_intervals + match_events + +Miscellaneous +------------- +.. autosummary:: + :toctree: generated/ + + localmax + peak_pick + + +Input validation +---------------- +.. autosummary:: + :toctree: generated/ + + valid_audio + valid_int + valid_intervals + + +File operations +--------------- + +.. autosummary:: + :toctree: generated/ + + example_audio_file + find_files + + +Deprecated +---------- +.. autosummary:: + :toctree: generated/ + + FeatureExtractor + buf_to_int + +""" + +from .utils import * # pylint: disable=wildcard-import +from .files import * # pylint: disable=wildcard-import +from .feature_extractor import * # pylint: disable=wildcard-import +from .deprecation import * # pylint: disable=wildcard-import +from . import decorators +from . import exceptions + +__all__ = [_ for _ in dir() if not _.startswith('_')] + diff --git a/librosa/util/decorators.py b/librosa/util/decorators.py new file mode 100644 index 0000000000..2064cab21a --- /dev/null +++ b/librosa/util/decorators.py @@ -0,0 +1,58 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +# CREATED:2015-02-15 10:06:03 by Brian McFee +'''Helpful tools for deprecation''' + +import warnings +from decorator import decorator +import six +import inspect + + +def moved(moved_from, version, version_removed): + '''This is a decorator which can be used to mark functions + as moved/renamed. + + It will result in a warning being emitted when the function is used. + ''' + + def __wrapper(func, *args, **kwargs): + '''Warn the user, and then proceed.''' + code = six.get_function_code(func) + warnings.warn_explicit( + "{:s}\n\tThis function was moved to '{:s}.{:s}' in " + "librosa version {:s}." + "\n\tThis alias will be removed in librosa version " + "{:s}.".format(moved_from, func.__module__, + func.__name__, version, version_removed), + + category=DeprecationWarning, + filename=code.co_filename, + lineno=code.co_firstlineno + 1 + ) + return func(*args, **kwargs) + + return decorator(__wrapper) + + +def deprecated(version, version_removed): + '''This is a decorator which can be used to mark functions + as deprecated. + + It will result in a warning being emitted when the function is used.''' + + def __wrapper(func, *args, **kwargs): + '''Warn the user, and then proceed.''' + code = six.get_function_code(func) + warnings.warn_explicit( + "{:s}.{:s}\n\tDeprecated as of librosa version {:s}." + "\n\tIt will be removed in librosa version {:s}." + .format(func.__module__, func.__name__, + version, version_removed), + category=DeprecationWarning, + filename=code.co_filename, + lineno=code.co_firstlineno + 1 + ) + return func(*args, **kwargs) + + return decorator(__wrapper) diff --git a/librosa/util/deprecation.py b/librosa/util/deprecation.py new file mode 100644 index 0000000000..f32b516f37 --- /dev/null +++ b/librosa/util/deprecation.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +#CREATED:2016-02-01 16:50:04 by Brian McFee +'''Deprecation utilities''' + +import inspect +import warnings + + +class Deprecated(object): + '''A dummy class to catch usage of deprecated variable names''' + def __repr__(self): + return '' + + +def rename_kw(old_name, old_value, new_name, new_value, version_deprecated, version_removed): + '''Handle renamed arguments. + + Parameters + ---------- + old_name : str + old_value + The name and value of the old argument + + new_name : str + new_value + The name and value of the new argument + + version_deprecated : str + The version at which the old name became deprecated + + version_removed : str + The version at which the old name will be removed + + Returns + ------- + value + - `new_value` if `old_value` of type `Deprecated` + - `old_value` otherwise + + Warnings + -------- + if `old_value` is not of type `Deprecated` + + ''' + if isinstance(old_value, Deprecated): + return new_value + else: + stack = inspect.stack() + dep_func = stack[1] + caller = stack[2] + + warnings.warn_explicit("{:s}() keyword argument '{:s}' has been renamed to '{:s}' in " + "version {:}." + "\n\tThis alias will be removed in version " + "{:}.".format(dep_func[3], + old_name, new_name, + version_deprecated, version_removed), + category=DeprecationWarning, + filename=caller[1], + lineno=caller[2]) + + return old_value + diff --git a/librosa/util/example_data/Kevin_MacLeod_-_Vibe_Ace.ogg b/librosa/util/example_data/Kevin_MacLeod_-_Vibe_Ace.ogg new file mode 100644 index 0000000000..0bd03628b4 Binary files /dev/null and b/librosa/util/example_data/Kevin_MacLeod_-_Vibe_Ace.ogg differ diff --git a/librosa/util/exceptions.py b/librosa/util/exceptions.py new file mode 100644 index 0000000000..7bbacebbf9 --- /dev/null +++ b/librosa/util/exceptions.py @@ -0,0 +1,13 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +'''Exception classes for librosa''' + + +class LibrosaError(Exception): + '''The root librosa exception class''' + pass + + +class ParameterError(LibrosaError): + '''Exception class for mal-formed inputs''' + pass diff --git a/librosa/util/feature_extractor.py b/librosa/util/feature_extractor.py new file mode 100644 index 0000000000..8e9f6b9518 --- /dev/null +++ b/librosa/util/feature_extractor.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""scikit-learn feature extraction integration""" + +from .decorators import deprecated +from sklearn.base import BaseEstimator, TransformerMixin + +__all__ = ['FeatureExtractor'] + + +class FeatureExtractor(BaseEstimator, TransformerMixin): + """Sci-kit learn wrapper class for feature extraction methods. + + This class acts as a bridge between feature extraction functions + and scikit-learn pipelines. + + .. warning:: The `FeatureExtractor` object is deprecated as of 0.4.2, and will be + removed in 0.5. + Instead, use `sklearn.preprocessing.FunctionTransformer`. + + Attributes + ---------- + function : function + The feature extraction function to wrap. + + Example: `librosa.feature.melspectrogram` + + target : str or None + If `None`, then `function` is called with the input + data as the first positional argument. + + If `str`, then `function` is called with the input + data as a keyword argument with key `target`. + + iterate : bool + If `True`, then `function` is applied iteratively to each + item of the input. + + If `False`, then `function` is applied to the entire data + stream simultaneously. This is useful for things like aggregation + and stacking. + + kwargs : additional keyword arguments + Parameters to be passed through to `function` + + Examples + -------- + >>> import sklearn.pipeline + >>> # Build a mel-spectrogram extractor + >>> MS = librosa.util.FeatureExtractor(librosa.feature.melspectrogram, + ... sr=22050, n_fft=2048, + ... n_mels=128, fmax=8000) + >>> # And a log-amplitude extractor + >>> LA = librosa.util.FeatureExtractor(librosa.logamplitude, + ... ref_power=np.max) + >>> # Chain them into a pipeline + >>> Features = sklearn.pipeline.Pipeline([('MelSpectrogram', MS), + ... ('LogAmplitude', LA)]) + >>> # Load an audio file + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> # Apply the transformation to y + >>> F = Features.transform([y]) + """ + + @deprecated('0.4.2', '0.5') + def __init__(self, function, target=None, iterate=True, **kwargs): + '''FeatureExtractor constructor + + ''' + self.function = function + self.target = target + self.iterate = iterate + self.kwargs = {} + + self.set_params(**kwargs) + + # Clobber _get_param_names here for transparency + def _get_param_names(self): + """Returns the parameters of the feature extractor as a dictionary.""" + temp_params = {'function': self.function, 'target': self.target} + + temp_params.update(self.kwargs) + + return temp_params + + # Wrap set_params to catch updates + def set_params(self, **kwargs): + """Update the parameters of the feature extractor.""" + + # We don't want non-functional arguments polluting kwargs + params = kwargs.copy() + for k in ['function', 'target']: + params.pop(k, None) + + self.kwargs.update(params) + BaseEstimator.set_params(self, **kwargs) + + # We keep these arguments for compatibility, but don't use them. + def fit(self, *args, **kwargs): # pylint: disable=unused-argument + """This function does nothing, and is provided for interface compatibility. + + .. note:: Since most `TransformerMixin` classes implement some + statistical modeling (e.g., PCA), the `fit()` method is + required. + + For the `FeatureExtraction` class, all parameters are fixed + ahead of time, and no statistical estimation takes place. + """ + + return self + + # Variable name 'X' is for consistency with sklearn + def transform(self, X): # pylint: disable=invalid-name + """Applies the feature transformation to an array of input data. + + Parameters + ---------- + X : iterable + Array or list of input data + + Returns + ------- + X_transform : list + In positional argument mode (`target=None`), then + `X_transform[i] = function(X[i], [feature parameters])` + + If the `target` parameter was given, then + `X_transform[i] = function(target=X[i], [feature parameters])` + """ + + if self.target is not None: + # If we have a target, each element of X takes the keyword argument + if self.iterate: + return [self.function(**dict(list(self.kwargs.items()) + + list({self.target: i}.items()))) + for i in X] + else: + return self.function(**dict(list(self.kwargs.items()) + + list({self.target: X}.items()))) + else: + # Each element of X takes first position in function() + if self.iterate: + return [self.function(i, **self.kwargs) for i in X] + else: + return self.function(X, **self.kwargs) diff --git a/librosa/util/files.py b/librosa/util/files.py new file mode 100644 index 0000000000..12d3c49630 --- /dev/null +++ b/librosa/util/files.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Utility functions for dealing with files""" + +import os +import glob +import pkg_resources + +import six + +EXAMPLE_AUDIO = 'example_data/Kevin_MacLeod_-_Vibe_Ace.ogg' + + +__all__ = ['example_audio_file', 'find_files'] + + +def example_audio_file(): + '''Get the path to an included audio example file. + + Examples + -------- + >>> # Load the waveform from the example track + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + + Returns + ------- + filename : str + Path to the audio example file included with librosa + + .. raw:: html + +
+ Vibe Ace + (Kevin MacLeod) + / CC BY 3.0 +
+ ''' + + return pkg_resources.resource_filename(__name__, EXAMPLE_AUDIO) + + +def find_files(directory, ext=None, recurse=True, case_sensitive=False, + limit=None, offset=0): + '''Get a sorted list of (audio) files in a directory or directory sub-tree. + + Examples + -------- + >>> # Get all audio files in a directory sub-tree + >>> files = librosa.util.find_files('~/Music') + + >>> # Look only within a specific directory, not the sub-tree + >>> files = librosa.util.find_files('~/Music', recurse=False) + + >>> # Only look for mp3 files + >>> files = librosa.util.find_files('~/Music', ext='mp3') + + >>> # Or just mp3 and ogg + >>> files = librosa.util.find_files('~/Music', ext=['mp3', 'ogg']) + + >>> # Only get the first 10 files + >>> files = librosa.util.find_files('~/Music', limit=10) + + >>> # Or last 10 files + >>> files = librosa.util.find_files('~/Music', offset=-10) + + Parameters + ---------- + directory : str + Path to look for files + + ext : str or list of str + A file extension or list of file extensions to include in the search. + + Default: `['aac', 'au', 'flac', 'm4a', 'mp3', 'ogg', 'wav']` + + recurse : boolean + If `True`, then all subfolders of `directory` will be searched. + + Otherwise, only `directory` will be searched. + + case_sensitive : boolean + If `False`, files matching upper-case version of + extensions will be included. + + limit : int > 0 or None + Return at most `limit` files. If `None`, all files are returned. + + offset : int + Return files starting at `offset` within the list. + + Use negative values to offset from the end of the list. + + Returns + ------- + files : list of str + The list of audio files. + ''' + + if ext is None: + ext = ['aac', 'au', 'flac', 'm4a', 'mp3', 'ogg', 'wav'] + + elif isinstance(ext, six.string_types): + ext = [ext] + + # Cast into a set + ext = set(ext) + + # Generate upper-case versions + if not case_sensitive: + # Force to lower-case + ext = set([e.lower() for e in ext]) + # Add in upper-case versions + ext |= set([e.upper() for e in ext]) + + files = [] + + if recurse: + for walk in os.walk(directory): + files.extend(__get_files(walk[0], ext)) + else: + files = __get_files(directory, ext) + + files.sort() + files = files[offset:] + if limit is not None: + files = files[:limit] + + return files + + +def __get_files(dir_name, extensions): + '''Helper function to get files in a single directory''' + + # Expand out the directory + dir_name = os.path.abspath(os.path.expanduser(dir_name)) + + myfiles = [] + + for sub_ext in extensions: + globstr = os.path.join(dir_name, '*' + os.path.extsep + sub_ext) + myfiles.extend(glob.glob(globstr)) + + return myfiles diff --git a/librosa/util/utils.py b/librosa/util/utils.py new file mode 100644 index 0000000000..4a9c44c66f --- /dev/null +++ b/librosa/util/utils.py @@ -0,0 +1,1339 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Utility functions""" + +import numpy as np +import scipy.ndimage +import scipy.sparse +import six + +from numpy.lib.stride_tricks import as_strided + +from .. import cache +from . import decorators +from .exceptions import ParameterError + +# Constrain STFT block sizes to 256 KB +MAX_MEM_BLOCK = 2**8 * 2**10 + +SMALL_FLOAT = 1e-20 + +__all__ = ['MAX_MEM_BLOCK', 'SMALL_FLOAT', + 'frame', 'pad_center', 'fix_length', + 'valid_audio', 'valid_int', 'valid_intervals', + 'fix_frames', + 'axis_sort', 'localmax', 'normalize', + 'match_intervals', 'match_events', + 'peak_pick', + 'sparsify_rows', + 'index_to_slice', + 'sync', + 'buf_to_float', + # Deprecated functions + 'buf_to_int'] + + +def frame(y, frame_length=2048, hop_length=512): + '''Slice a time series into overlapping frames. + + This implementation uses low-level stride manipulation to avoid + redundant copies of the time series data. + + Parameters + ---------- + y : np.ndarray [shape=(n,)] + Time series to frame. Must be one-dimensional and contiguous + in memory. + + frame_length : int > 0 [scalar] + Length of the frame in samples + + hop_length : int > 0 [scalar] + Number of samples to hop between frames + + Returns + ------- + y_frames : np.ndarray [shape=(frame_length, N_FRAMES)] + An array of frames sampled from `y`: + `y_frames[i, j] == y[j * hop_length + i]` + + Raises + ------ + ParameterError + If `y` is not contiguous in memory, framing is invalid. + See `np.ascontiguous()` for details. + + If `hop_length < 1`, frames cannot advance. + + Examples + -------- + Extract 2048-sample frames from `y` with a hop of 64 samples per frame + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.util.frame(y, frame_length=2048, hop_length=64) + array([[ -9.216e-06, 7.710e-06, ..., -2.117e-06, -4.362e-07], + [ 2.518e-06, -6.294e-06, ..., -1.775e-05, -6.365e-06], + ..., + [ -7.429e-04, 5.173e-03, ..., 1.105e-05, -5.074e-06], + [ 2.169e-03, 4.867e-03, ..., 3.666e-06, -5.571e-06]], dtype=float32) + + ''' + + if hop_length < 1: + raise ParameterError('Invalid hop_length: {:d}'.format(hop_length)) + + if not y.flags['C_CONTIGUOUS']: + raise ParameterError('Input buffer must be contiguous.') + + valid_audio(y) + + # Compute the number of frames that will fit. The end may get truncated. + n_frames = 1 + int((len(y) - frame_length) / hop_length) + + if n_frames < 1: + raise ParameterError('Buffer is too short (n={:d})' + ' for frame_length={:d}'.format(len(y), + frame_length)) + # Vertical stride is one sample + # Horizontal stride is `hop_length` samples + y_frames = as_strided(y, shape=(frame_length, n_frames), + strides=(y.itemsize, hop_length * y.itemsize)) + return y_frames + + +@cache +def valid_audio(y, mono=True): + '''Validate whether a variable contains valid, mono audio data. + + + Parameters + ---------- + y : np.ndarray + The input data to validate + + mono : bool + Whether or not to force monophonic audio + + Returns + ------- + valid : bool + True if all tests pass + + Raises + ------ + ParameterError + If `y` fails to meet the following criteria: + - `type(y)` is `np.ndarray` + - `mono == True` and `y.ndim` is not 1 + - `mono == False` and `y.ndim` is not 1 or 2 + - `np.isfinite(y).all()` is not True + + Examples + -------- + >>> # Only allow monophonic signals + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> librosa.util.valid_audio(y) + True + + >>> # If we want to allow stereo signals + >>> y, sr = librosa.load(librosa.util.example_audio_file(), mono=False) + >>> librosa.util.valid_audio(y, mono=False) + True + ''' + + if not isinstance(y, np.ndarray): + raise ParameterError('data must be of type numpy.ndarray') + + if mono and y.ndim != 1: + raise ParameterError('Invalid shape for monophonic audio: ' + 'ndim={:d}, shape={}'.format(y.ndim, + y.shape)) + elif y.ndim > 2: + raise ParameterError('Invalid shape for audio: ' + 'ndim={:d}, shape={}'.format(y.ndim, + y.shape)) + + if not np.isfinite(y).all(): + raise ParameterError('Audio buffer is not finite everywhere') + + return True + + +def valid_int(x, cast=None): + '''Ensure that an input value is integer-typed. + This is primarily useful for ensuring integrable-valued + array indices. + + Parameters + ---------- + x : number + A scalar value to be cast to int + + cast : function [optional] + A function to modify `x` before casting. + Default: `np.floor` + + Returns + ------- + x_int : int + `x_int = int(cast(x))` + + Raises + ------ + ParameterError + If `cast` is provided and is not callable. + ''' + + if cast is None: + cast = np.floor + + if not six.callable(cast): + raise ParameterError('cast parameter must be callable') + + return int(cast(x)) + + +def valid_intervals(intervals): + '''Ensure that an array is a valid representation of time intervals: + + - intervals.ndim == 2 + - intervals.shape[1] == 2 + + Parameters + ---------- + intervals : np.ndarray [shape=(n, 2)] + set of time intervals + + Returns + ------- + valid : bool + True if `intervals` passes validation. + ''' + + if intervals.ndim != 2 or intervals.shape[-1] != 2: + raise ParameterError('intervals must have shape (n, 2)') + + return True + + +@cache +def pad_center(data, size, axis=-1, **kwargs): + '''Wrapper for np.pad to automatically center an array prior to padding. + This is analogous to `str.center()` + + Examples + -------- + >>> # Generate a vector + >>> data = np.ones(5) + >>> librosa.util.pad_center(data, 10, mode='constant') + array([ 0., 0., 1., 1., 1., 1., 1., 0., 0., 0.]) + + >>> # Pad a matrix along its first dimension + >>> data = np.ones((3, 5)) + >>> librosa.util.pad_center(data, 7, axis=0) + array([[ 0., 0., 0., 0., 0.], + [ 0., 0., 0., 0., 0.], + [ 1., 1., 1., 1., 1.], + [ 1., 1., 1., 1., 1.], + [ 1., 1., 1., 1., 1.], + [ 0., 0., 0., 0., 0.], + [ 0., 0., 0., 0., 0.]]) + >>> # Or its second dimension + >>> librosa.util.pad_center(data, 7, axis=1) + array([[ 0., 1., 1., 1., 1., 1., 0.], + [ 0., 1., 1., 1., 1., 1., 0.], + [ 0., 1., 1., 1., 1., 1., 0.]]) + + Parameters + ---------- + data : np.ndarray + Vector to be padded and centered + + size : int >= len(data) [scalar] + Length to pad `data` + + axis : int + Axis along which to pad and center the data + + kwargs : additional keyword arguments + arguments passed to `np.pad()` + + Returns + ------- + data_padded : np.ndarray + `data` centered and padded to length `size` along the + specified axis + + Raises + ------ + ParameterError + If `size < data.shape[axis]` + + See Also + -------- + numpy.pad + ''' + + kwargs.setdefault('mode', 'constant') + + n = data.shape[axis] + + lpad = int((size - n) // 2) + + lengths = [(0, 0)] * data.ndim + lengths[axis] = (lpad, int(size - n - lpad)) + + if lpad < 0: + raise ParameterError(('Target size ({:d}) must be ' + 'at least input size ({:d})').format(size, + n)) + + return np.pad(data, lengths, **kwargs) + + +@cache +def fix_length(data, size, axis=-1, **kwargs): + '''Fix the length an array `data` to exactly `size`. + + If `data.shape[axis] < n`, pad according to the provided kwargs. + By default, `data` is padded with trailing zeros. + + Examples + -------- + >>> y = np.arange(7) + >>> # Default: pad with zeros + >>> librosa.util.fix_length(y, 10) + array([0, 1, 2, 3, 4, 5, 6, 0, 0, 0]) + >>> # Trim to a desired length + >>> librosa.util.fix_length(y, 5) + array([0, 1, 2, 3, 4]) + >>> # Use edge-padding instead of zeros + >>> librosa.util.fix_length(y, 10, mode='edge') + array([0, 1, 2, 3, 4, 5, 6, 6, 6, 6]) + + Parameters + ---------- + data : np.ndarray + array to be length-adjusted + + size : int >= 0 [scalar] + desired length of the array + + axis : int, <= data.ndim + axis along which to fix length + + kwargs : additional keyword arguments + Parameters to `np.pad()` + + Returns + ------- + data_fixed : np.ndarray [shape=data.shape] + `data` either trimmed or padded to length `size` + along the specified axis. + + See Also + -------- + numpy.pad + ''' + + kwargs.setdefault('mode', 'constant') + + n = data.shape[axis] + + if n > size: + slices = [slice(None)] * data.ndim + slices[axis] = slice(0, size) + return data[slices] + + elif n < size: + lengths = [(0, 0)] * data.ndim + lengths[axis] = (0, size - n) + return np.pad(data, lengths, **kwargs) + + return data + + +def fix_frames(frames, x_min=0, x_max=None, pad=True): + '''Fix a list of frames to lie within [x_min, x_max] + + Examples + -------- + >>> # Generate a list of frame indices + >>> frames = np.arange(0, 1000.0, 50) + >>> frames + array([ 0., 50., 100., 150., 200., 250., 300., 350., + 400., 450., 500., 550., 600., 650., 700., 750., + 800., 850., 900., 950.]) + >>> # Clip to span at most 250 + >>> librosa.util.fix_frames(frames, x_max=250) + array([ 0, 50, 100, 150, 200, 250]) + >>> # Or pad to span up to 2500 + >>> librosa.util.fix_frames(frames, x_max=2500) + array([ 0, 50, 100, 150, 200, 250, 300, 350, 400, + 450, 500, 550, 600, 650, 700, 750, 800, 850, + 900, 950, 2500]) + >>> librosa.util.fix_frames(frames, x_max=2500, pad=False) + array([ 0, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, + 550, 600, 650, 700, 750, 800, 850, 900, 950]) + + >>> # Or starting away from zero + >>> frames = np.arange(200, 500, 33) + >>> frames + array([200, 233, 266, 299, 332, 365, 398, 431, 464, 497]) + >>> librosa.util.fix_frames(frames) + array([ 0, 200, 233, 266, 299, 332, 365, 398, 431, 464, 497]) + >>> librosa.util.fix_frames(frames, x_max=500) + array([ 0, 200, 233, 266, 299, 332, 365, 398, 431, 464, 497, + 500]) + + + Parameters + ---------- + frames : np.ndarray [shape=(n_frames,)] + List of non-negative frame indices + + x_min : int >= 0 or None + Minimum allowed frame index + + x_max : int >= 0 or None + Maximum allowed frame index + + pad : boolean + If `True`, then `frames` is expanded to span the full range + `[x_min, x_max]` + + Returns + ------- + fixed_frames : np.ndarray [shape=(n_fixed_frames,), dtype=int] + Fixed frame indices, flattened and sorted + + Raises + ------ + ParameterError + If `frames` contains negative values + ''' + + frames = np.asarray(frames) + + if np.any(frames < 0): + raise ParameterError('Negative frame index detected') + + if pad and (x_min is not None or x_max is not None): + frames = np.clip(frames, x_min, x_max) + + if pad: + pad_data = [] + if x_min is not None: + pad_data.append(x_min) + if x_max is not None: + pad_data.append(x_max) + frames = np.concatenate((pad_data, frames)) + + if x_min is not None: + frames = frames[frames >= x_min] + + if x_max is not None: + frames = frames[frames <= x_max] + + return np.unique(frames).astype(int) + + +@cache +def axis_sort(S, axis=-1, index=False, value=None): + '''Sort an array along its rows or columns. + + Examples + -------- + Visualize NMF output for a spectrogram S + + >>> # Sort the columns of W by peak frequency bin + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> S = np.abs(librosa.stft(y)) + >>> W, H = librosa.decompose.decompose(S, n_components=32) + >>> W_sort = librosa.util.axis_sort(W) + + Or sort by the lowest frequency bin + + >>> W_sort = librosa.util.axis_sort(W, value=np.argmin) + + Or sort the rows instead of the columns + + >>> W_sort_rows = librosa.util.axis_sort(W, axis=0) + + Get the sorting index also, and use it to permute the rows of H + + >>> W_sort, idx = librosa.util.axis_sort(W, index=True) + >>> H_sort = H[idx, :] + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 2, 1) + >>> librosa.display.specshow(librosa.logamplitude(W**2, ref_power=np.max), + ... y_axis='log') + >>> plt.title('W') + >>> plt.subplot(2, 2, 2) + >>> librosa.display.specshow(H, x_axis='time') + >>> plt.title('H') + >>> plt.subplot(2, 2, 3) + >>> librosa.display.specshow(librosa.logamplitude(W_sort**2, + ... ref_power=np.max), + ... y_axis='log') + >>> plt.title('W sorted') + >>> plt.subplot(2, 2, 4) + >>> librosa.display.specshow(H_sort, x_axis='time') + >>> plt.title('H sorted') + >>> plt.tight_layout() + + + Parameters + ---------- + S : np.ndarray [shape=(d, n)] + Array to be sorted + + axis : int [scalar] + The axis along which to compute the sorting values + + - `axis=0` to sort rows by peak column index + - `axis=1` to sort columns by peak row index + + index : boolean [scalar] + If true, returns the index array as well as the permuted data. + + value : function + function to return the index corresponding to the sort order. + Default: `np.argmax`. + + Returns + ------- + S_sort : np.ndarray [shape=(d, n)] + `S` with the columns or rows permuted in sorting order + + idx : np.ndarray (optional) [shape=(d,) or (n,)] + If `index == True`, the sorting index used to permute `S`. + Length of `idx` corresponds to the selected `axis`. + + Raises + ------ + ParameterError + If `S` does not have exactly 2 dimensions (`S.ndim != 2`) + ''' + + if value is None: + value = np.argmax + + if S.ndim != 2: + raise ParameterError('axis_sort is only defined for 2D arrays') + + bin_idx = value(S, axis=np.mod(1-axis, S.ndim)) + idx = np.argsort(bin_idx) + + sort_slice = [slice(None)] * S.ndim + sort_slice[axis] = idx + + if index: + return S[sort_slice], idx + else: + return S[sort_slice] + + +@cache +def normalize(S, norm=np.inf, axis=0): + '''Normalize the columns or rows of a matrix + + .. note:: + Columns/rows with length 0 will be left as zeros. + + Examples + -------- + >>> # Construct an example matrix + >>> S = np.vander(np.arange(-2.0, 2.0)) + >>> S + array([[-8., 4., -2., 1.], + [-1., 1., -1., 1.], + [ 0., 0., 0., 1.], + [ 1., 1., 1., 1.]]) + >>> # Max (l-infinity)-normalize the columns + >>> librosa.util.normalize(S) + array([[-1. , 1. , -1. , 1. ], + [-0.125, 0.25 , -0.5 , 1. ], + [ 0. , 0. , 0. , 1. ], + [ 0.125, 0.25 , 0.5 , 1. ]]) + >>> # Max (l-infinity)-normalize the rows + >>> librosa.util.normalize(S, axis=1) + array([[-1. , 0.5 , -0.25 , 0.125], + [-1. , 1. , -1. , 1. ], + [ 0. , 0. , 0. , 1. ], + [ 1. , 1. , 1. , 1. ]]) + >>> # l1-normalize the columns + >>> librosa.util.normalize(S, norm=1) + array([[-0.8 , 0.667, -0.5 , 0.25 ], + [-0.1 , 0.167, -0.25 , 0.25 ], + [ 0. , 0. , 0. , 0.25 ], + [ 0.1 , 0.167, 0.25 , 0.25 ]]) + >>> # l2-normalize the columns + >>> librosa.util.normalize(S, norm=2) + array([[-0.985, 0.943, -0.816, 0.5 ], + [-0.123, 0.236, -0.408, 0.5 ], + [ 0. , 0. , 0. , 0.5 ], + [ 0.123, 0.236, 0.408, 0.5 ]]) + + Parameters + ---------- + S : np.ndarray [shape=(d, n)] + The matrix to normalize + + norm : {np.inf, -np.inf, 0, float > 0, None} + - `np.inf` : maximum absolute value + - `-np.inf` : mininum absolute value + - `0` : number of non-zeros + - float : corresponding l_p norm. + See `scipy.linalg.norm` for details. + - None : no normalization is performed + + axis : int [scalar] + Axis along which to compute the norm. + `axis=0` will normalize columns, `axis=1` will normalize rows. + `axis=None` will normalize according to the entire matrix. + + Returns + ------- + S_norm : np.ndarray [shape=S.shape] + Normalized matrix + + Raises + ------ + ParameterError + If `norm` is not among the valid types defined above + ''' + + # All norms only depend on magnitude, let's do that first + mag = np.abs(S) + + if norm == np.inf: + length = np.max(mag, axis=axis, keepdims=True) + + elif norm == -np.inf: + length = np.min(mag, axis=axis, keepdims=True) + + elif norm == 0: + length = np.sum(mag > 0, axis=axis, keepdims=True) + + elif np.issubdtype(type(norm), np.number) and norm > 0: + length = np.sum(mag ** norm, axis=axis, keepdims=True)**(1./norm) + + elif norm is None: + return S + + else: + raise ParameterError('Unsupported norm: {}'.format(repr(norm))) + + # Avoid div-by-zero + length[length < SMALL_FLOAT] = 1.0 + + return S / length + + +@cache +def match_intervals(intervals_from, intervals_to): + '''Match one set of time intervals to another. + + This can be useful for tasks such as mapping beat timings + to segments. + + .. note:: A target interval may be matched to multiple source + intervals. + + Parameters + ---------- + intervals_from : np.ndarray [shape=(n, 2)] + The time range for source intervals. + The `i` th interval spans time `intervals_from[i, 0]` + to `intervals_from[i, 1]`. + `intervals_from[0, 0]` should be 0, `intervals_from[-1, 1]` + should be the track duration. + + intervals_to : np.ndarray [shape=(m, 2)] + Analogous to `intervals_from`. + + Returns + ------- + interval_mapping : np.ndarray [shape=(n,)] + For each interval in `intervals_from`, the + corresponding interval in `intervals_to`. + + See Also + -------- + match_events + + Raises + ------ + ParameterError + If either array of input intervals is not the correct shape + ''' + + if len(intervals_from) == 0 or len(intervals_to) == 0: + raise ParameterError('Attempting to match empty interval list') + + # Verify that the input intervals has correct shape and size + valid_intervals(intervals_from) + valid_intervals(intervals_to) + + # The overlap score of a beat with a segment is defined as + # max(0, min(beat_end, segment_end) - max(beat_start, segment_start)) + output = np.empty(len(intervals_from), dtype=np.int) + + n_rows = int(MAX_MEM_BLOCK / (len(intervals_to) * intervals_to.itemsize)) + n_rows = max(1, n_rows) + + for bl_s in range(0, len(intervals_from), n_rows): + bl_t = min(bl_s + n_rows, len(intervals_from)) + tmp_from = intervals_from[bl_s:bl_t] + + starts = np.maximum.outer(tmp_from[:, 0], intervals_to[:, 0]) + ends = np.minimum.outer(tmp_from[:, 1], intervals_to[:, 1]) + score = np.maximum(0, ends - starts) + + output[bl_s:bl_t] = np.argmax(score, axis=-1) + + return output + + +@cache +def match_events(events_from, events_to): + '''Match one set of events to another. + + This is useful for tasks such as matching beats to the nearest + detected onsets, or frame-aligned events to the nearest zero-crossing. + + .. note:: A target event may be matched to multiple source events. + + Examples + -------- + >>> # Sources are multiples of 7 + >>> s_from = np.arange(0, 100, 7) + >>> s_from + array([ 0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, + 98]) + >>> # Targets are multiples of 10 + >>> s_to = np.arange(0, 100, 10) + >>> s_to + array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90]) + >>> # Find the matching + >>> idx = librosa.util.match_events(s_from, s_to) + >>> idx + array([0, 1, 1, 2, 3, 3, 4, 5, 6, 6, 7, 8, 8, 9, 9]) + >>> # Print each source value to its matching target + >>> zip(s_from, s_to[idx]) + [(0, 0), (7, 10), (14, 10), (21, 20), (28, 30), (35, 30), + (42, 40), (49, 50), (56, 60), (63, 60), (70, 70), (77, 80), + (84, 80), (91, 90), (98, 90)] + + Parameters + ---------- + events_from : ndarray [shape=(n,)] + Array of events (eg, times, sample or frame indices) to match from. + + events_to : ndarray [shape=(m,)] + Array of events (eg, times, sample or frame indices) to + match against. + + Returns + ------- + event_mapping : np.ndarray [shape=(n,)] + For each event in `events_from`, the corresponding event + index in `events_to`. + + `event_mapping[i] == arg min |events_from[i] - events_to[:]|` + + See Also + -------- + match_intervals + + Raises + ------ + ParameterError + If either array of input events is not the correct shape + ''' + + if len(events_from) == 0 or len(events_to) == 0: + raise ParameterError('Attempting to match empty event list') + + output = np.empty_like(events_from, dtype=np.int) + + n_rows = int(MAX_MEM_BLOCK / (np.prod(output.shape[1:]) * len(events_to) + * events_from.itemsize)) + + # Make sure we can at least make some progress + n_rows = max(1, n_rows) + + # Iterate over blocks of the data + for bl_s in range(0, len(events_from), n_rows): + bl_t = min(bl_s + n_rows, len(events_from)) + + event_block = events_from[bl_s:bl_t] + output[bl_s:bl_t] = np.argmin(np.abs(np.subtract.outer(event_block, + events_to)), + axis=-1) + + return output + + +@cache +def localmax(x, axis=0): + """Find local maxima in an array `x`. + + Examples + -------- + >>> x = np.array([1, 0, 1, 2, -1, 0, -2, 1]) + >>> librosa.util.localmax(x) + array([False, False, False, True, False, True, False, True], dtype=bool) + + >>> # Two-dimensional example + >>> x = np.array([[1,0,1], [2, -1, 0], [2, 1, 3]]) + >>> librosa.util.localmax(x, axis=0) + array([[False, False, False], + [ True, False, False], + [False, True, True]], dtype=bool) + >>> librosa.util.localmax(x, axis=1) + array([[False, False, True], + [False, False, True], + [False, False, True]], dtype=bool) + + Parameters + ---------- + x : np.ndarray [shape=(d1,d2,...)] + input vector or array + + axis : int + axis along which to compute local maximality + + Returns + ------- + m : np.ndarray [shape=x.shape, dtype=bool] + indicator array of local maximality along `axis` + + """ + + paddings = [(0, 0)] * x.ndim + paddings[axis] = (1, 1) + + x_pad = np.pad(x, paddings, mode='edge') + + inds1 = [slice(None)] * x.ndim + inds1[axis] = slice(0, -2) + + inds2 = [slice(None)] * x.ndim + inds2[axis] = slice(2, x_pad.shape[axis]) + + return (x > x_pad[inds1]) & (x >= x_pad[inds2]) + + +@cache +def peak_pick(x, pre_max, post_max, pre_avg, post_avg, delta, wait): + '''Uses a flexible heuristic to pick peaks in a signal. + + A sample n is selected as an peak if the corresponding x[n] + fulfills the following three conditions: + + 1. `x[n] == max(x[n - pre_max:n + post_max])` + 2. `x[n] >= mean(x[n - pre_avg:n + post_avg]) + delta` + 3. `n - previous_n > wait` + + where `previous_n` is the last sample picked as a peak (greedily). + + This implementation is based on [1]_ and [2]_. + + .. [1] Boeck, Sebastian, Florian Krebs, and Markus Schedl. + "Evaluating the Online Capabilities of Onset Detection Methods." ISMIR. + 2012. + + .. [2] https://github.com/CPJKU/onset_detection/blob/master/onset_program.py + + + Parameters + ---------- + x : np.ndarray [shape=(n,)] + input signal to peak picks from + + pre_max : int >= 0 [scalar] + number of samples before `n` over which max is computed + + post_max : int >= 1 [scalar] + number of samples after `n` over which max is computed + + pre_avg : int >= 0 [scalar] + number of samples before `n` over which mean is computed + + post_avg : int >= 1 [scalar] + number of samples after `n` over which mean is computed + + delta : float >= 0 [scalar] + threshold offset for mean + + wait : int >= 0 [scalar] + number of samples to wait after picking a peak + + Returns + ------- + peaks : np.ndarray [shape=(n_peaks,), dtype=int] + indices of peaks in `x` + + Raises + ------ + ParameterError + If any input lies outside its defined range + + Examples + -------- + >>> y, sr = librosa.load(librosa.util.example_audio_file(), duration=15) + >>> onset_env = librosa.onset.onset_strength(y=y, sr=sr, + ... hop_length=512, + ... aggregate=np.median) + >>> peaks = librosa.util.peak_pick(onset_env, 3, 3, 3, 5, 0.5, 10) + >>> peaks + array([ 4, 23, 73, 102, 142, 162, 182, 211, 261, 301, 320, + 331, 348, 368, 382, 396, 411, 431, 446, 461, 476, 491, + 510, 525, 536, 555, 570, 590, 609, 625, 639]) + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(2, 1, 1) + >>> plt.plot(onset_env[:30 * sr // 512], alpha=0.8, label='Onset strength') + >>> plt.vlines(peaks[peaks < 30 * sr // 512], 0, + ... onset_env.max(), color='r', alpha=0.8, + ... label='Selected peaks') + >>> plt.legend(frameon=True, framealpha=0.8) + >>> plt.axis('tight') + >>> plt.axis('off') + >>> plt.subplot(2, 1, 2) + >>> D = np.abs(librosa.stft(y))**2 + >>> librosa.display.specshow(librosa.logamplitude(D, ref_power=np.max), + ... y_axis='log', x_axis='time') + >>> plt.tight_layout() + ''' + + if pre_max < 0: + raise ParameterError('pre_max must be non-negative') + if pre_avg < 0: + raise ParameterError('pre_avg must be non-negative') + if delta < 0: + raise ParameterError('delta must be non-negative') + if wait < 0: + raise ParameterError('wait must be non-negative') + + if post_max <= 0: + raise ParameterError('post_max must be positive') + + if post_avg <= 0: + raise ParameterError('post_avg must be positive') + + if x.ndim != 1: + raise ParameterError('input array must be one-dimensional') + + # Ensure valid index types + pre_max = valid_int(pre_max, cast=np.ceil) + post_max = valid_int(post_max, cast=np.ceil) + pre_avg = valid_int(pre_avg, cast=np.ceil) + post_avg = valid_int(post_avg, cast=np.ceil) + wait = valid_int(wait, cast=np.ceil) + + # Get the maximum of the signal over a sliding window + max_length = pre_max + post_max + max_origin = np.ceil(0.5 * (pre_max - post_max)) + # Using mode='constant' and cval=x.min() effectively truncates + # the sliding window at the boundaries + mov_max = scipy.ndimage.filters.maximum_filter1d(x, int(max_length), + mode='constant', + origin=int(max_origin), + cval=x.min()) + + # Get the mean of the signal over a sliding window + avg_length = pre_avg + post_avg + avg_origin = np.ceil(0.5 * (pre_avg - post_avg)) + # Here, there is no mode which results in the behavior we want, + # so we'll correct below. + mov_avg = scipy.ndimage.filters.uniform_filter1d(x, int(avg_length), + mode='nearest', + origin=int(avg_origin)) + + # Correct sliding average at the beginning + n = 0 + # Only need to correct in the range where the window needs to be truncated + while n - pre_avg < 0 and n < x.shape[0]: + # This just explicitly does mean(x[n - pre_avg:n + post_avg]) + # with truncation + start = n - pre_avg + start = start if start > 0 else 0 + mov_avg[n] = np.mean(x[start:n + post_avg]) + n += 1 + # Correct sliding average at the end + n = x.shape[0] - post_avg + # When post_avg > x.shape[0] (weird case), reset to 0 + n = n if n > 0 else 0 + while n < x.shape[0]: + start = n - pre_avg + start = start if start > 0 else 0 + mov_avg[n] = np.mean(x[start:n + post_avg]) + n += 1 + + # First mask out all entries not equal to the local max + detections = x * (x == mov_max) + + # Then mask out all entries less than the thresholded average + detections = detections * (detections >= (mov_avg + delta)) + + # Initialize peaks array, to be filled greedily + peaks = [] + + # Remove onsets which are close together in time + last_onset = -np.inf + + for i in np.nonzero(detections)[0]: + # Only report an onset if the "wait" samples was reported + if i > last_onset + wait: + peaks.append(i) + # Save last reported onset + last_onset = i + + return np.array(peaks) + + +@cache +def sparsify_rows(x, quantile=0.01): + ''' + Return a row-sparse matrix approximating the input `x`. + + Examples + -------- + >>> # Construct a Hann window to sparsify + >>> x = scipy.signal.hann(32) + >>> x + array([ 0. , 0.01 , 0.041, 0.09 , 0.156, 0.236, 0.326, + 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, + 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, + 0.72 , 0.625, 0.525, 0.424, 0.326, 0.236, 0.156, + 0.09 , 0.041, 0.01 , 0. ]) + >>> # Discard the bottom percentile + >>> x_sparse = librosa.util.sparsify_rows(x, quantile=0.01) + >>> x_sparse + <1x32 sparse matrix of type '' + with 26 stored elements in Compressed Sparse Row format> + >>> x_sparse.todense() + matrix([[ 0. , 0. , 0. , 0.09 , 0.156, 0.236, 0.326, + 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, + 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, + 0.72 , 0.625, 0.525, 0.424, 0.326, 0.236, 0.156, + 0.09 , 0. , 0. , 0. ]]) + >>> # Discard up to the bottom 10th percentile + >>> x_sparse = librosa.util.sparsify_rows(x, quantile=0.1) + >>> x_sparse + <1x32 sparse matrix of type '' + with 20 stored elements in Compressed Sparse Row format> + >>> x_sparse.todense() + matrix([[ 0. , 0. , 0. , 0. , 0. , 0. , 0.326, + 0.424, 0.525, 0.625, 0.72 , 0.806, 0.879, 0.937, + 0.977, 0.997, 0.997, 0.977, 0.937, 0.879, 0.806, + 0.72 , 0.625, 0.525, 0.424, 0.326, 0. , 0. , + 0. , 0. , 0. , 0. ]]) + + Parameters + ---------- + x : np.ndarray [ndim <= 2] + The input matrix to sparsify. + + quantile : float in [0, 1.0) + Percentage of magnitude to discard in each row of `x` + + Returns + ------- + x_sparse : `scipy.sparse.csr_matrix` [shape=x.shape] + Row-sparsified approximation of `x` + + If `x.ndim == 1`, then `x` is interpreted as a row vector, + and `x_sparse.shape == (1, len(x))`. + + Raises + ------ + ParameterError + If `x.ndim > 2` + + If `quantile` lies outside `[0, 1.0)` + ''' + + if x.ndim == 1: + x = x.reshape((1, -1)) + + elif x.ndim > 2: + raise ParameterError('Input must have 2 or fewer dimensions. ' + 'Provided x.shape={}.'.format(x.shape)) + + if not (0.0 <= quantile < 1): + raise ParameterError('Invalid quantile {:.2f}'.format(quantile)) + + x_sparse = scipy.sparse.lil_matrix(x.shape, dtype=x.dtype) + + mags = np.abs(x) + norms = np.sum(mags, axis=1, keepdims=True) + + mag_sort = np.sort(mags, axis=1) + cumulative_mag = np.cumsum(mag_sort / norms, axis=1) + + threshold_idx = np.argmin(cumulative_mag < quantile, axis=1) + + for i, j in enumerate(threshold_idx): + idx = np.where(mags[i] >= mag_sort[i, j]) + x_sparse[i, idx] = x[i, idx] + + return x_sparse.tocsr() + + +def buf_to_float(x, n_bytes=2, dtype=np.float32): + """Convert an integer buffer to floating point values. + This is primarily useful when loading integer-valued wav data + into numpy arrays. + + See Also + -------- + buf_to_float + + Parameters + ---------- + x : np.ndarray [dtype=int] + The integer-valued data buffer + + n_bytes : int [1, 2, 4] + The number of bytes per sample in `x` + + dtype : numeric type + The target output type (default: 32-bit float) + + Returns + ------- + x_float : np.ndarray [dtype=float] + The input data buffer cast to floating point + """ + + # Invert the scale of the data + scale = 1./float(1 << ((8 * n_bytes) - 1)) + + # Construct the format string + fmt = '>> # Generate slices from spaced indices + >>> librosa.util.index_to_slice(np.arange(20, 100, 15)) + [slice(20, 35, None), slice(35, 50, None), slice(50, 65, None), slice(65, 80, None), + slice(80, 95, None)] + >>> # Pad to span the range (0, 100) + >>> librosa.util.index_to_slice(np.arange(20, 100, 15), + ... idx_min=0, idx_max=100) + [slice(0, 20, None), slice(20, 35, None), slice(35, 50, None), slice(50, 65, None), + slice(65, 80, None), slice(80, 95, None), slice(95, 100, None)] + >>> # Use a step of 5 for each slice + >>> librosa.util.index_to_slice(np.arange(20, 100, 15), + ... idx_min=0, idx_max=100, step=5) + [slice(0, 20, 5), slice(20, 35, 5), slice(35, 50, 5), slice(50, 65, 5), slice(65, 80, 5), + slice(80, 95, 5), slice(95, 100, 5)] + ''' + + # First, normalize the index set + idx_fixed = fix_frames(idx, idx_min, idx_max, pad=pad) + + # Now convert the indices to slices + return [slice(start, end, step) for (start, end) in zip(idx_fixed, idx_fixed[1:])] + + +@cache +def sync(data, idx, aggregate=None, pad=True, axis=-1): + """Synchronous aggregation of a multi-dimensional array between boundaries + + .. note:: + In order to ensure total coverage, boundary points may be added + to `idx`. + + If synchronizing a feature matrix against beat tracker output, ensure + that frame index numbers are properly aligned and use the same hop length. + + Parameters + ---------- + data : np.ndarray + multi-dimensional array of features + + idx : iterable of ints or slices + Either an ordered array of boundary indices, or + an iterable collection of slice objects. + + + aggregate : function + aggregation function (default: `np.mean`) + + pad : boolean + If `True`, `idx` is padded to span the full range `[0, data.shape[axis]]` + + axis : int + The axis along which to aggregate data + + Returns + ------- + data_sync : ndarray + `data_sync` will have the same dimension as `data`, except that the `axis` + coordinate will be reduced according to `idx`. + + For example, a 2-dimensional `data` with `axis=-1` should satisfy + + `data_sync[:, i] = aggregate(data[:, idx[i-1]:idx[i]], axis=-1)` + + Raises + ------ + ParameterError + If the index set is not of consistent type (all slices or all integers) + + Examples + -------- + Beat-synchronous CQT spectra + + >>> y, sr = librosa.load(librosa.util.example_audio_file()) + >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr) + >>> cqt = librosa.cqt(y=y, sr=sr) + + By default, use mean aggregation + + >>> cqt_avg = librosa.util.sync(cqt, beats) + + Use median-aggregation instead of mean + + >>> cqt_med = librosa.util.sync(cqt, beats, + ... aggregate=np.median) + + Or sub-beat synchronization + + >>> sub_beats = librosa.segment.subsegment(cqt, beats) + >>> cqt_med_sub = librosa.util.sync(cqt, sub_beats, aggregate=np.median) + + + Plot the results + + >>> import matplotlib.pyplot as plt + >>> plt.figure() + >>> plt.subplot(3, 1, 1) + >>> librosa.display.specshow(librosa.logamplitude(cqt**2, + ... ref_power=np.max), + ... x_axis='time') + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('CQT power, shape={}'.format(cqt.shape)) + >>> plt.subplot(3, 1, 2) + >>> librosa.display.specshow(librosa.logamplitude(cqt_med**2, + ... ref_power=np.max)) + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Beat synchronous CQT power, ' + ... 'shape={}'.format(cqt_med.shape)) + >>> plt.subplot(3, 1, 3) + >>> librosa.display.specshow(librosa.logamplitude(cqt_med_sub**2, + ... ref_power=np.max)) + >>> plt.colorbar(format='%+2.0f dB') + >>> plt.title('Sub-beat synchronous CQT power, ' + ... 'shape={}'.format(cqt_med_sub.shape)) + >>> plt.tight_layout() + + """ + + if aggregate is None: + aggregate = np.mean + + shape = list(data.shape) + + if np.all([isinstance(_, slice) for _ in idx]): + slices = idx + elif np.all([np.issubdtype(type(_), np.int) for _ in idx]): + slices = index_to_slice(np.asarray(idx), 0, shape[axis], pad=pad) + else: + raise ParameterError('Invalid index set: {}'.format(idx)) + + agg_shape = list(shape) + agg_shape[axis] = len(slices) + + data_agg = np.empty(agg_shape, order='F' if np.isfortran(data) else 'C', dtype=data.dtype) + + idx_in = [slice(None)] * data.ndim + idx_agg = [slice(None)] * data_agg.ndim + + for (i, segment) in enumerate(slices): + idx_in[axis] = segment + idx_agg[axis] = i + data_agg[idx_agg] = aggregate(data[idx_in], axis=axis) + + return data_agg + + +# Deprecated functions + +@decorators.deprecated('0.4', '0.5') +def buf_to_int(x, n_bytes=2): # pragma: no cover + """Convert a floating point buffer into integer values. + This is primarily useful as an intermediate step in wav output. + + See Also + -------- + buf_to_float + + Parameters + ---------- + x : np.ndarray [dtype=float] + Floating point data buffer + + n_bytes : int [1, 2, 4] + Number of bytes per output sample + + Returns + ------- + x_int : np.ndarray [dtype=int] + The original buffer cast to integer type. + """ + + if n_bytes not in [1, 2, 4]: + raise ParameterError('n_bytes must be one of {1, 2, 4}') + + # What is the scale of the input data? + scale = float(1 << ((8 * n_bytes) - 1)) + + # Construct a format string + fmt = '= 2.0.0', + 'numpy >= 1.8.0', + 'scipy >= 0.13.0', + 'scikit-learn >= 0.14.0', + 'matplotlib >= 1.4.3', + 'joblib >= 0.7.0', + 'decorator >= 3.0.0', + 'six >= 1.3', + 'resampy >= 0.1.0' + ], + extras_require={ + 'resample': 'scikits.samplerate>=0.3', + 'docs': ['numpydoc', 'seaborn', 'sphinx_rtd_theme'] + } +) diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 0000000000..d519485c13 --- /dev/null +++ b/tests/README.md @@ -0,0 +1,38 @@ +Tests +======= + +This directory contains compatibility tests for librosa's core features. + +The MATLAB script ``makeTestData.m`` generates input/output examples under the ``data/`` directory. + +After generating the test data, run ``nosetests -v`` to perform tests and verify the outputs. + + +Generating test data +==================== + +The data files for numerical equivalence tests are generated by the ``makeTestData`` matlab program. This relies on a variety of matlab functions which can be downloaded from the following URLs: + + - http://www.ee.columbia.edu/~dpwe/resources/matlab/rastamat/ + - http://www.ee.columbia.edu/~dpwe/resources/matlab/chroma-ansyn/ + +The following [RASTAMAT](http://www.ee.columbia.edu/~dpwe/resources/matlab/rastamat/) functions are required to run the ``makeTestData.m`` matlab program: + + - ``mel2hz.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/rastamat/mel2hz.m + - ``hz2mel.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/rastamat/hz2mel.m + - ``fft2melmx.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/rastamat/fft2melmx.m + +STFT/ISTFT are compared to those available [here](http://www.ee.columbia.edu/ln/rosa/matlab/pvoc/): + + - ``stft.m`` http://www.ee.columbia.edu/ln/rosa/matlab/pvoc/stft.m + - ``istft.m`` http://www.ee.columbia.edu/ln/rosa/matlab/pvoc/istft.m + +Beat tracking implementations are provided [here](http://labrosa.ee.columbia.edu/projects/beattrack/): + - ``tempo2.m`` http://labrosa.ee.columbia.edu/projects/beattrack/tempo2.m + - ``beat2.m`` http://labrosa.ee.columbia.edu/projects/beattrack/beat2.m + +The [chroma-ansyn](http://www.ee.columbia.edu/~dpwe/resources/matlab/chroma-ansyn/chroma-ansyn.tgz) package provides the remaining functions: + + - ``hz2octs.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/chroma-ansyn/hz2octs.m + - ``ifgram.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/chroma-ansyn/ifgram.m + - ``fft2chromamx.m`` http://www.ee.columbia.edu/~dpwe/resources/matlab/chroma-ansyn/fft2chromamx.m diff --git a/tests/baseline_images/test_display/abs.png b/tests/baseline_images/test_display/abs.png new file mode 100644 index 0000000000..3964f49e2f Binary files /dev/null and b/tests/baseline_images/test_display/abs.png differ diff --git a/tests/baseline_images/test_display/chroma.png b/tests/baseline_images/test_display/chroma.png new file mode 100644 index 0000000000..bd4e51b741 Binary files /dev/null and b/tests/baseline_images/test_display/chroma.png differ diff --git a/tests/baseline_images/test_display/complex.png b/tests/baseline_images/test_display/complex.png new file mode 100644 index 0000000000..a621b7d1aa Binary files /dev/null and b/tests/baseline_images/test_display/complex.png differ diff --git a/tests/baseline_images/test_display/cqt_hz.png b/tests/baseline_images/test_display/cqt_hz.png new file mode 100644 index 0000000000..c447a2c5ec Binary files /dev/null and b/tests/baseline_images/test_display/cqt_hz.png differ diff --git a/tests/baseline_images/test_display/cqt_note.png b/tests/baseline_images/test_display/cqt_note.png new file mode 100644 index 0000000000..23be389d2b Binary files /dev/null and b/tests/baseline_images/test_display/cqt_note.png differ diff --git a/tests/baseline_images/test_display/double_chroma.png b/tests/baseline_images/test_display/double_chroma.png new file mode 100644 index 0000000000..bc3d237fbe Binary files /dev/null and b/tests/baseline_images/test_display/double_chroma.png differ diff --git a/tests/baseline_images/test_display/tempo.png b/tests/baseline_images/test_display/tempo.png new file mode 100644 index 0000000000..2d193a76ec Binary files /dev/null and b/tests/baseline_images/test_display/tempo.png differ diff --git a/tests/baseline_images/test_display/time_scales_auto.png b/tests/baseline_images/test_display/time_scales_auto.png new file mode 100644 index 0000000000..945db3adb7 Binary files /dev/null and b/tests/baseline_images/test_display/time_scales_auto.png differ diff --git a/tests/baseline_images/test_display/time_scales_explicit.png b/tests/baseline_images/test_display/time_scales_explicit.png new file mode 100644 index 0000000000..a796065af3 Binary files /dev/null and b/tests/baseline_images/test_display/time_scales_explicit.png differ diff --git a/tests/baseline_images/test_display/tonnetz.png b/tests/baseline_images/test_display/tonnetz.png new file mode 100644 index 0000000000..3f0314590a Binary files /dev/null and b/tests/baseline_images/test_display/tonnetz.png differ diff --git a/tests/baseline_images/test_display/waveplot_mono.png b/tests/baseline_images/test_display/waveplot_mono.png new file mode 100644 index 0000000000..2eb146d4d9 Binary files /dev/null and b/tests/baseline_images/test_display/waveplot_mono.png differ diff --git a/tests/baseline_images/test_display/waveplot_stereo.png b/tests/baseline_images/test_display/waveplot_stereo.png new file mode 100644 index 0000000000..ad4c93d690 Binary files /dev/null and b/tests/baseline_images/test_display/waveplot_stereo.png differ diff --git a/tests/baseline_images/test_display/x_frames_y_none.png b/tests/baseline_images/test_display/x_frames_y_none.png new file mode 100644 index 0000000000..9ee04c0be0 Binary files /dev/null and b/tests/baseline_images/test_display/x_frames_y_none.png differ diff --git a/tests/baseline_images/test_display/x_lag_y_none.png b/tests/baseline_images/test_display/x_lag_y_none.png new file mode 100644 index 0000000000..22bde78e4b Binary files /dev/null and b/tests/baseline_images/test_display/x_lag_y_none.png differ diff --git a/tests/baseline_images/test_display/x_linear_y_none.png b/tests/baseline_images/test_display/x_linear_y_none.png new file mode 100644 index 0000000000..83d070502c Binary files /dev/null and b/tests/baseline_images/test_display/x_linear_y_none.png differ diff --git a/tests/baseline_images/test_display/x_log_y_none.png b/tests/baseline_images/test_display/x_log_y_none.png new file mode 100644 index 0000000000..ca881f3549 Binary files /dev/null and b/tests/baseline_images/test_display/x_log_y_none.png differ diff --git a/tests/baseline_images/test_display/x_mel.png b/tests/baseline_images/test_display/x_mel.png new file mode 100644 index 0000000000..705535c714 Binary files /dev/null and b/tests/baseline_images/test_display/x_mel.png differ diff --git a/tests/baseline_images/test_display/x_none_y_frames.png b/tests/baseline_images/test_display/x_none_y_frames.png new file mode 100644 index 0000000000..609358723a Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_frames.png differ diff --git a/tests/baseline_images/test_display/x_none_y_lag.png b/tests/baseline_images/test_display/x_none_y_lag.png new file mode 100644 index 0000000000..5ae652f8f8 Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_lag.png differ diff --git a/tests/baseline_images/test_display/x_none_y_linear.png b/tests/baseline_images/test_display/x_none_y_linear.png new file mode 100644 index 0000000000..0d3a7ad191 Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_linear.png differ diff --git a/tests/baseline_images/test_display/x_none_y_log.png b/tests/baseline_images/test_display/x_none_y_log.png new file mode 100644 index 0000000000..544ec6977a Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_log.png differ diff --git a/tests/baseline_images/test_display/x_none_y_log_ghz.png b/tests/baseline_images/test_display/x_none_y_log_ghz.png new file mode 100644 index 0000000000..e9dda0f6ca Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_log_ghz.png differ diff --git a/tests/baseline_images/test_display/x_none_y_log_khz.png b/tests/baseline_images/test_display/x_none_y_log_khz.png new file mode 100644 index 0000000000..69bd79d996 Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_log_khz.png differ diff --git a/tests/baseline_images/test_display/x_none_y_log_megahz.png b/tests/baseline_images/test_display/x_none_y_log_megahz.png new file mode 100644 index 0000000000..9fca488a7a Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_log_megahz.png differ diff --git a/tests/baseline_images/test_display/x_none_y_log_mhz.png b/tests/baseline_images/test_display/x_none_y_log_mhz.png new file mode 100644 index 0000000000..2fc8d3373a Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_log_mhz.png differ diff --git a/tests/baseline_images/test_display/x_none_y_time.png b/tests/baseline_images/test_display/x_none_y_time.png new file mode 100644 index 0000000000..392c30bb0e Binary files /dev/null and b/tests/baseline_images/test_display/x_none_y_time.png differ diff --git a/tests/baseline_images/test_display/x_time_y_none.png b/tests/baseline_images/test_display/x_time_y_none.png new file mode 100644 index 0000000000..7177ad23bb Binary files /dev/null and b/tests/baseline_images/test_display/x_time_y_none.png differ diff --git a/tests/baseline_images/test_display/y_mel.png b/tests/baseline_images/test_display/y_mel.png new file mode 100644 index 0000000000..9d8b5051bf Binary files /dev/null and b/tests/baseline_images/test_display/y_mel.png differ diff --git a/tests/baseline_images/test_display/y_mel_bounded.png b/tests/baseline_images/test_display/y_mel_bounded.png new file mode 100644 index 0000000000..7dc1a6ccad Binary files /dev/null and b/tests/baseline_images/test_display/y_mel_bounded.png differ diff --git a/tests/data/beat-beat-000.mat b/tests/data/beat-beat-000.mat new file mode 100644 index 0000000000..f924570678 Binary files /dev/null and b/tests/data/beat-beat-000.mat differ diff --git a/tests/data/beat-onset-000.mat b/tests/data/beat-onset-000.mat new file mode 100644 index 0000000000..a214e6b1c9 Binary files /dev/null and b/tests/data/beat-onset-000.mat differ diff --git a/tests/data/beat-tempo-000.mat b/tests/data/beat-tempo-000.mat new file mode 100644 index 0000000000..fec6b918e4 Binary files /dev/null and b/tests/data/beat-tempo-000.mat differ diff --git a/tests/data/core-ifgram-001.mat b/tests/data/core-ifgram-001.mat new file mode 100644 index 0000000000..3022fe1c6b Binary files /dev/null and b/tests/data/core-ifgram-001.mat differ diff --git a/tests/data/core-ifgram-002.mat b/tests/data/core-ifgram-002.mat new file mode 100644 index 0000000000..e13b34a1fc Binary files /dev/null and b/tests/data/core-ifgram-002.mat differ diff --git a/tests/data/core-ifgram-003.mat b/tests/data/core-ifgram-003.mat new file mode 100644 index 0000000000..bab89f2228 Binary files /dev/null and b/tests/data/core-ifgram-003.mat differ diff --git a/tests/data/core-ifgram-004.mat b/tests/data/core-ifgram-004.mat new file mode 100644 index 0000000000..7bb3290fa7 Binary files /dev/null and b/tests/data/core-ifgram-004.mat differ diff --git a/tests/data/core-ifgram-005.mat b/tests/data/core-ifgram-005.mat new file mode 100644 index 0000000000..9484157059 Binary files /dev/null and b/tests/data/core-ifgram-005.mat differ diff --git a/tests/data/core-ifgram-006.mat b/tests/data/core-ifgram-006.mat new file mode 100644 index 0000000000..13c3ff7585 Binary files /dev/null and b/tests/data/core-ifgram-006.mat differ diff --git a/tests/data/core-ifgram-007.mat b/tests/data/core-ifgram-007.mat new file mode 100644 index 0000000000..f6218afe74 Binary files /dev/null and b/tests/data/core-ifgram-007.mat differ diff --git a/tests/data/core-ifgram-008.mat b/tests/data/core-ifgram-008.mat new file mode 100644 index 0000000000..fee3abfdac Binary files /dev/null and b/tests/data/core-ifgram-008.mat differ diff --git a/tests/data/core-ifgram-009.mat b/tests/data/core-ifgram-009.mat new file mode 100644 index 0000000000..b6962aa193 Binary files /dev/null and b/tests/data/core-ifgram-009.mat differ diff --git a/tests/data/core-istft-001.mat b/tests/data/core-istft-001.mat new file mode 100644 index 0000000000..7e5118738e Binary files /dev/null and b/tests/data/core-istft-001.mat differ diff --git a/tests/data/core-istft-002.mat b/tests/data/core-istft-002.mat new file mode 100644 index 0000000000..580dbb4008 Binary files /dev/null and b/tests/data/core-istft-002.mat differ diff --git a/tests/data/core-istft-003.mat b/tests/data/core-istft-003.mat new file mode 100644 index 0000000000..8829743e81 Binary files /dev/null and b/tests/data/core-istft-003.mat differ diff --git a/tests/data/core-istft-004.mat b/tests/data/core-istft-004.mat new file mode 100644 index 0000000000..84d85713ab Binary files /dev/null and b/tests/data/core-istft-004.mat differ diff --git a/tests/data/core-istft-005.mat b/tests/data/core-istft-005.mat new file mode 100644 index 0000000000..46a69457cb Binary files /dev/null and b/tests/data/core-istft-005.mat differ diff --git a/tests/data/core-istft-006.mat b/tests/data/core-istft-006.mat new file mode 100644 index 0000000000..9b8093931c Binary files /dev/null and b/tests/data/core-istft-006.mat differ diff --git a/tests/data/core-istft-007.mat b/tests/data/core-istft-007.mat new file mode 100644 index 0000000000..26d56e61ab Binary files /dev/null and b/tests/data/core-istft-007.mat differ diff --git a/tests/data/core-istft-008.mat b/tests/data/core-istft-008.mat new file mode 100644 index 0000000000..2079565ace Binary files /dev/null and b/tests/data/core-istft-008.mat differ diff --git a/tests/data/core-istft-009.mat b/tests/data/core-istft-009.mat new file mode 100644 index 0000000000..e82a8316cb Binary files /dev/null and b/tests/data/core-istft-009.mat differ diff --git a/tests/data/core-istft-010.mat b/tests/data/core-istft-010.mat new file mode 100644 index 0000000000..b017abe4a3 Binary files /dev/null and b/tests/data/core-istft-010.mat differ diff --git a/tests/data/core-istft-011.mat b/tests/data/core-istft-011.mat new file mode 100644 index 0000000000..4e30ea92bf Binary files /dev/null and b/tests/data/core-istft-011.mat differ diff --git a/tests/data/core-istft-012.mat b/tests/data/core-istft-012.mat new file mode 100644 index 0000000000..6c8d046548 Binary files /dev/null and b/tests/data/core-istft-012.mat differ diff --git a/tests/data/core-istft-013.mat b/tests/data/core-istft-013.mat new file mode 100644 index 0000000000..38e69903f3 Binary files /dev/null and b/tests/data/core-istft-013.mat differ diff --git a/tests/data/core-istft-014.mat b/tests/data/core-istft-014.mat new file mode 100644 index 0000000000..0a9c4cdb5f Binary files /dev/null and b/tests/data/core-istft-014.mat differ diff --git a/tests/data/core-istft-015.mat b/tests/data/core-istft-015.mat new file mode 100644 index 0000000000..79becf65d8 Binary files /dev/null and b/tests/data/core-istft-015.mat differ diff --git a/tests/data/core-istft-016.mat b/tests/data/core-istft-016.mat new file mode 100644 index 0000000000..a1bbdea82c Binary files /dev/null and b/tests/data/core-istft-016.mat differ diff --git a/tests/data/core-istft-017.mat b/tests/data/core-istft-017.mat new file mode 100644 index 0000000000..e4e98c93f9 Binary files /dev/null and b/tests/data/core-istft-017.mat differ diff --git a/tests/data/core-istft-018.mat b/tests/data/core-istft-018.mat new file mode 100644 index 0000000000..5cca3b0a81 Binary files /dev/null and b/tests/data/core-istft-018.mat differ diff --git a/tests/data/core-load-001.mat b/tests/data/core-load-001.mat new file mode 100644 index 0000000000..86f4471195 Binary files /dev/null and b/tests/data/core-load-001.mat differ diff --git a/tests/data/core-load-002.mat b/tests/data/core-load-002.mat new file mode 100644 index 0000000000..29d80cfed9 Binary files /dev/null and b/tests/data/core-load-002.mat differ diff --git a/tests/data/core-resample-001.mat b/tests/data/core-resample-001.mat new file mode 100644 index 0000000000..c40186710a Binary files /dev/null and b/tests/data/core-resample-001.mat differ diff --git a/tests/data/core-resample-002.mat b/tests/data/core-resample-002.mat new file mode 100644 index 0000000000..19aa479d6d Binary files /dev/null and b/tests/data/core-resample-002.mat differ diff --git a/tests/data/core-resample-003.mat b/tests/data/core-resample-003.mat new file mode 100644 index 0000000000..082ccd31a6 Binary files /dev/null and b/tests/data/core-resample-003.mat differ diff --git a/tests/data/core-stft-001.mat b/tests/data/core-stft-001.mat new file mode 100644 index 0000000000..f958839019 Binary files /dev/null and b/tests/data/core-stft-001.mat differ diff --git a/tests/data/core-stft-002.mat b/tests/data/core-stft-002.mat new file mode 100644 index 0000000000..3ecb2f3736 Binary files /dev/null and b/tests/data/core-stft-002.mat differ diff --git a/tests/data/core-stft-003.mat b/tests/data/core-stft-003.mat new file mode 100644 index 0000000000..96a5e8f619 Binary files /dev/null and b/tests/data/core-stft-003.mat differ diff --git a/tests/data/core-stft-004.mat b/tests/data/core-stft-004.mat new file mode 100644 index 0000000000..4ce43c76dd Binary files /dev/null and b/tests/data/core-stft-004.mat differ diff --git a/tests/data/core-stft-005.mat b/tests/data/core-stft-005.mat new file mode 100644 index 0000000000..167a52546a Binary files /dev/null and b/tests/data/core-stft-005.mat differ diff --git a/tests/data/core-stft-006.mat b/tests/data/core-stft-006.mat new file mode 100644 index 0000000000..ab8b2fee24 Binary files /dev/null and b/tests/data/core-stft-006.mat differ diff --git a/tests/data/core-stft-007.mat b/tests/data/core-stft-007.mat new file mode 100644 index 0000000000..9538da7e7c Binary files /dev/null and b/tests/data/core-stft-007.mat differ diff --git a/tests/data/core-stft-008.mat b/tests/data/core-stft-008.mat new file mode 100644 index 0000000000..988939db89 Binary files /dev/null and b/tests/data/core-stft-008.mat differ diff --git a/tests/data/core-stft-009.mat b/tests/data/core-stft-009.mat new file mode 100644 index 0000000000..5fac8ae9ac Binary files /dev/null and b/tests/data/core-stft-009.mat differ diff --git a/tests/data/core-stft-010.mat b/tests/data/core-stft-010.mat new file mode 100644 index 0000000000..c25a9bedc0 Binary files /dev/null and b/tests/data/core-stft-010.mat differ diff --git a/tests/data/core-stft-011.mat b/tests/data/core-stft-011.mat new file mode 100644 index 0000000000..f5bde6769a Binary files /dev/null and b/tests/data/core-stft-011.mat differ diff --git a/tests/data/core-stft-012.mat b/tests/data/core-stft-012.mat new file mode 100644 index 0000000000..20fcc63579 Binary files /dev/null and b/tests/data/core-stft-012.mat differ diff --git a/tests/data/core-stft-013.mat b/tests/data/core-stft-013.mat new file mode 100644 index 0000000000..e28615c7ba Binary files /dev/null and b/tests/data/core-stft-013.mat differ diff --git a/tests/data/core-stft-014.mat b/tests/data/core-stft-014.mat new file mode 100644 index 0000000000..17a5f6e4ae Binary files /dev/null and b/tests/data/core-stft-014.mat differ diff --git a/tests/data/core-stft-015.mat b/tests/data/core-stft-015.mat new file mode 100644 index 0000000000..25f2b2da79 Binary files /dev/null and b/tests/data/core-stft-015.mat differ diff --git a/tests/data/core-stft-016.mat b/tests/data/core-stft-016.mat new file mode 100644 index 0000000000..09e4001b68 Binary files /dev/null and b/tests/data/core-stft-016.mat differ diff --git a/tests/data/core-stft-017.mat b/tests/data/core-stft-017.mat new file mode 100644 index 0000000000..5b12c470ce Binary files /dev/null and b/tests/data/core-stft-017.mat differ diff --git a/tests/data/core-stft-018.mat b/tests/data/core-stft-018.mat new file mode 100644 index 0000000000..d263172ebe Binary files /dev/null and b/tests/data/core-stft-018.mat differ diff --git a/tests/data/feature-chromafb-001.mat b/tests/data/feature-chromafb-001.mat new file mode 100644 index 0000000000..0a2938e481 Binary files /dev/null and b/tests/data/feature-chromafb-001.mat differ diff --git a/tests/data/feature-chromafb-002.mat b/tests/data/feature-chromafb-002.mat new file mode 100644 index 0000000000..484ac4555c Binary files /dev/null and b/tests/data/feature-chromafb-002.mat differ diff --git a/tests/data/feature-chromafb-003.mat b/tests/data/feature-chromafb-003.mat new file mode 100644 index 0000000000..bf02da7e14 Binary files /dev/null and b/tests/data/feature-chromafb-003.mat differ diff --git a/tests/data/feature-chromafb-004.mat b/tests/data/feature-chromafb-004.mat new file mode 100644 index 0000000000..299fe59bc1 Binary files /dev/null and b/tests/data/feature-chromafb-004.mat differ diff --git a/tests/data/feature-chromafb-005.mat b/tests/data/feature-chromafb-005.mat new file mode 100644 index 0000000000..ea56a48433 Binary files /dev/null and b/tests/data/feature-chromafb-005.mat differ diff --git a/tests/data/feature-chromafb-006.mat b/tests/data/feature-chromafb-006.mat new file mode 100644 index 0000000000..7cc135d1c9 Binary files /dev/null and b/tests/data/feature-chromafb-006.mat differ diff --git a/tests/data/feature-chromafb-007.mat b/tests/data/feature-chromafb-007.mat new file mode 100644 index 0000000000..82228f749e Binary files /dev/null and b/tests/data/feature-chromafb-007.mat differ diff --git a/tests/data/feature-chromafb-008.mat b/tests/data/feature-chromafb-008.mat new file mode 100644 index 0000000000..8669b41d5b Binary files /dev/null and b/tests/data/feature-chromafb-008.mat differ diff --git a/tests/data/feature-chromafb-009.mat b/tests/data/feature-chromafb-009.mat new file mode 100644 index 0000000000..939afbe51d Binary files /dev/null and b/tests/data/feature-chromafb-009.mat differ diff --git a/tests/data/feature-chromafb-010.mat b/tests/data/feature-chromafb-010.mat new file mode 100644 index 0000000000..9465cfbfe6 Binary files /dev/null and b/tests/data/feature-chromafb-010.mat differ diff --git a/tests/data/feature-chromafb-011.mat b/tests/data/feature-chromafb-011.mat new file mode 100644 index 0000000000..4e893ac008 Binary files /dev/null and b/tests/data/feature-chromafb-011.mat differ diff --git a/tests/data/feature-chromafb-012.mat b/tests/data/feature-chromafb-012.mat new file mode 100644 index 0000000000..6a9c27cb42 Binary files /dev/null and b/tests/data/feature-chromafb-012.mat differ diff --git a/tests/data/feature-chromafb-013.mat b/tests/data/feature-chromafb-013.mat new file mode 100644 index 0000000000..110cd9b99c Binary files /dev/null and b/tests/data/feature-chromafb-013.mat differ diff --git a/tests/data/feature-chromafb-014.mat b/tests/data/feature-chromafb-014.mat new file mode 100644 index 0000000000..ebdc97aac7 Binary files /dev/null and b/tests/data/feature-chromafb-014.mat differ diff --git a/tests/data/feature-chromafb-015.mat b/tests/data/feature-chromafb-015.mat new file mode 100644 index 0000000000..3d7ea15c8f Binary files /dev/null and b/tests/data/feature-chromafb-015.mat differ diff --git a/tests/data/feature-chromafb-016.mat b/tests/data/feature-chromafb-016.mat new file mode 100644 index 0000000000..9a03205872 Binary files /dev/null and b/tests/data/feature-chromafb-016.mat differ diff --git a/tests/data/feature-chromafb-017.mat b/tests/data/feature-chromafb-017.mat new file mode 100644 index 0000000000..d29ab10ac6 Binary files /dev/null and b/tests/data/feature-chromafb-017.mat differ diff --git a/tests/data/feature-chromafb-018.mat b/tests/data/feature-chromafb-018.mat new file mode 100644 index 0000000000..192c47fdaa Binary files /dev/null and b/tests/data/feature-chromafb-018.mat differ diff --git a/tests/data/feature-chromafb-019.mat b/tests/data/feature-chromafb-019.mat new file mode 100644 index 0000000000..8434581357 Binary files /dev/null and b/tests/data/feature-chromafb-019.mat differ diff --git a/tests/data/feature-chromafb-020.mat b/tests/data/feature-chromafb-020.mat new file mode 100644 index 0000000000..d1482152da Binary files /dev/null and b/tests/data/feature-chromafb-020.mat differ diff --git a/tests/data/feature-chromafb-021.mat b/tests/data/feature-chromafb-021.mat new file mode 100644 index 0000000000..eb3df125d0 Binary files /dev/null and b/tests/data/feature-chromafb-021.mat differ diff --git a/tests/data/feature-chromafb-022.mat b/tests/data/feature-chromafb-022.mat new file mode 100644 index 0000000000..5f38c0d45e Binary files /dev/null and b/tests/data/feature-chromafb-022.mat differ diff --git a/tests/data/feature-chromafb-023.mat b/tests/data/feature-chromafb-023.mat new file mode 100644 index 0000000000..840ae6a0ec Binary files /dev/null and b/tests/data/feature-chromafb-023.mat differ diff --git a/tests/data/feature-chromafb-024.mat b/tests/data/feature-chromafb-024.mat new file mode 100644 index 0000000000..dc493919e4 Binary files /dev/null and b/tests/data/feature-chromafb-024.mat differ diff --git a/tests/data/feature-chromafb-025.mat b/tests/data/feature-chromafb-025.mat new file mode 100644 index 0000000000..8f58943bd9 Binary files /dev/null and b/tests/data/feature-chromafb-025.mat differ diff --git a/tests/data/feature-chromafb-026.mat b/tests/data/feature-chromafb-026.mat new file mode 100644 index 0000000000..c2050f39a7 Binary files /dev/null and b/tests/data/feature-chromafb-026.mat differ diff --git a/tests/data/feature-chromafb-027.mat b/tests/data/feature-chromafb-027.mat new file mode 100644 index 0000000000..58694b22a6 Binary files /dev/null and b/tests/data/feature-chromafb-027.mat differ diff --git a/tests/data/feature-chromafb-028.mat b/tests/data/feature-chromafb-028.mat new file mode 100644 index 0000000000..a7def2c70d Binary files /dev/null and b/tests/data/feature-chromafb-028.mat differ diff --git a/tests/data/feature-chromafb-029.mat b/tests/data/feature-chromafb-029.mat new file mode 100644 index 0000000000..864f884c45 Binary files /dev/null and b/tests/data/feature-chromafb-029.mat differ diff --git a/tests/data/feature-chromafb-030.mat b/tests/data/feature-chromafb-030.mat new file mode 100644 index 0000000000..2055a1c5b1 Binary files /dev/null and b/tests/data/feature-chromafb-030.mat differ diff --git a/tests/data/feature-chromafb-031.mat b/tests/data/feature-chromafb-031.mat new file mode 100644 index 0000000000..489beb7b08 Binary files /dev/null and b/tests/data/feature-chromafb-031.mat differ diff --git a/tests/data/feature-chromafb-032.mat b/tests/data/feature-chromafb-032.mat new file mode 100644 index 0000000000..1349688bcc Binary files /dev/null and b/tests/data/feature-chromafb-032.mat differ diff --git a/tests/data/feature-chromafb-033.mat b/tests/data/feature-chromafb-033.mat new file mode 100644 index 0000000000..6d441cee64 Binary files /dev/null and b/tests/data/feature-chromafb-033.mat differ diff --git a/tests/data/feature-chromafb-034.mat b/tests/data/feature-chromafb-034.mat new file mode 100644 index 0000000000..4a28879e4e Binary files /dev/null and b/tests/data/feature-chromafb-034.mat differ diff --git a/tests/data/feature-chromafb-035.mat b/tests/data/feature-chromafb-035.mat new file mode 100644 index 0000000000..1c60d7e195 Binary files /dev/null and b/tests/data/feature-chromafb-035.mat differ diff --git a/tests/data/feature-chromafb-036.mat b/tests/data/feature-chromafb-036.mat new file mode 100644 index 0000000000..a0dc288dc8 Binary files /dev/null and b/tests/data/feature-chromafb-036.mat differ diff --git a/tests/data/feature-chromafb-037.mat b/tests/data/feature-chromafb-037.mat new file mode 100644 index 0000000000..c3b143148c Binary files /dev/null and b/tests/data/feature-chromafb-037.mat differ diff --git a/tests/data/feature-chromafb-038.mat b/tests/data/feature-chromafb-038.mat new file mode 100644 index 0000000000..059cb7fb3a Binary files /dev/null and b/tests/data/feature-chromafb-038.mat differ diff --git a/tests/data/feature-chromafb-039.mat b/tests/data/feature-chromafb-039.mat new file mode 100644 index 0000000000..9643583da9 Binary files /dev/null and b/tests/data/feature-chromafb-039.mat differ diff --git a/tests/data/feature-chromafb-040.mat b/tests/data/feature-chromafb-040.mat new file mode 100644 index 0000000000..a600e7b7c6 Binary files /dev/null and b/tests/data/feature-chromafb-040.mat differ diff --git a/tests/data/feature-chromafb-041.mat b/tests/data/feature-chromafb-041.mat new file mode 100644 index 0000000000..f8f4515efa Binary files /dev/null and b/tests/data/feature-chromafb-041.mat differ diff --git a/tests/data/feature-chromafb-042.mat b/tests/data/feature-chromafb-042.mat new file mode 100644 index 0000000000..ec185d332d Binary files /dev/null and b/tests/data/feature-chromafb-042.mat differ diff --git a/tests/data/feature-chromafb-043.mat b/tests/data/feature-chromafb-043.mat new file mode 100644 index 0000000000..c8a19563ce Binary files /dev/null and b/tests/data/feature-chromafb-043.mat differ diff --git a/tests/data/feature-chromafb-044.mat b/tests/data/feature-chromafb-044.mat new file mode 100644 index 0000000000..9334e283c7 Binary files /dev/null and b/tests/data/feature-chromafb-044.mat differ diff --git a/tests/data/feature-chromafb-045.mat b/tests/data/feature-chromafb-045.mat new file mode 100644 index 0000000000..f1c9ea8291 Binary files /dev/null and b/tests/data/feature-chromafb-045.mat differ diff --git a/tests/data/feature-chromafb-046.mat b/tests/data/feature-chromafb-046.mat new file mode 100644 index 0000000000..a2761d9698 Binary files /dev/null and b/tests/data/feature-chromafb-046.mat differ diff --git a/tests/data/feature-chromafb-047.mat b/tests/data/feature-chromafb-047.mat new file mode 100644 index 0000000000..fe66fba4f6 Binary files /dev/null and b/tests/data/feature-chromafb-047.mat differ diff --git a/tests/data/feature-chromafb-048.mat b/tests/data/feature-chromafb-048.mat new file mode 100644 index 0000000000..623e222d43 Binary files /dev/null and b/tests/data/feature-chromafb-048.mat differ diff --git a/tests/data/feature-chromafb-049.mat b/tests/data/feature-chromafb-049.mat new file mode 100644 index 0000000000..64e7492b24 Binary files /dev/null and b/tests/data/feature-chromafb-049.mat differ diff --git a/tests/data/feature-chromafb-050.mat b/tests/data/feature-chromafb-050.mat new file mode 100644 index 0000000000..28ae85e762 Binary files /dev/null and b/tests/data/feature-chromafb-050.mat differ diff --git a/tests/data/feature-chromafb-051.mat b/tests/data/feature-chromafb-051.mat new file mode 100644 index 0000000000..20f90d86dc Binary files /dev/null and b/tests/data/feature-chromafb-051.mat differ diff --git a/tests/data/feature-chromafb-052.mat b/tests/data/feature-chromafb-052.mat new file mode 100644 index 0000000000..3ebc5a0b68 Binary files /dev/null and b/tests/data/feature-chromafb-052.mat differ diff --git a/tests/data/feature-chromafb-053.mat b/tests/data/feature-chromafb-053.mat new file mode 100644 index 0000000000..c593ed4685 Binary files /dev/null and b/tests/data/feature-chromafb-053.mat differ diff --git a/tests/data/feature-chromafb-054.mat b/tests/data/feature-chromafb-054.mat new file mode 100644 index 0000000000..d7b1b89e2f Binary files /dev/null and b/tests/data/feature-chromafb-054.mat differ diff --git a/tests/data/feature-chromafb-055.mat b/tests/data/feature-chromafb-055.mat new file mode 100644 index 0000000000..f093856d5c Binary files /dev/null and b/tests/data/feature-chromafb-055.mat differ diff --git a/tests/data/feature-chromafb-056.mat b/tests/data/feature-chromafb-056.mat new file mode 100644 index 0000000000..e093d04565 Binary files /dev/null and b/tests/data/feature-chromafb-056.mat differ diff --git a/tests/data/feature-chromafb-057.mat b/tests/data/feature-chromafb-057.mat new file mode 100644 index 0000000000..6cde5129b0 Binary files /dev/null and b/tests/data/feature-chromafb-057.mat differ diff --git a/tests/data/feature-chromafb-058.mat b/tests/data/feature-chromafb-058.mat new file mode 100644 index 0000000000..4c30df4ca1 Binary files /dev/null and b/tests/data/feature-chromafb-058.mat differ diff --git a/tests/data/feature-chromafb-059.mat b/tests/data/feature-chromafb-059.mat new file mode 100644 index 0000000000..4c0e6acc70 Binary files /dev/null and b/tests/data/feature-chromafb-059.mat differ diff --git a/tests/data/feature-chromafb-060.mat b/tests/data/feature-chromafb-060.mat new file mode 100644 index 0000000000..d4a4247cfc Binary files /dev/null and b/tests/data/feature-chromafb-060.mat differ diff --git a/tests/data/feature-chromafb-061.mat b/tests/data/feature-chromafb-061.mat new file mode 100644 index 0000000000..f02fcb09ef Binary files /dev/null and b/tests/data/feature-chromafb-061.mat differ diff --git a/tests/data/feature-chromafb-062.mat b/tests/data/feature-chromafb-062.mat new file mode 100644 index 0000000000..6e14a3cb1b Binary files /dev/null and b/tests/data/feature-chromafb-062.mat differ diff --git a/tests/data/feature-chromafb-063.mat b/tests/data/feature-chromafb-063.mat new file mode 100644 index 0000000000..db003dc323 Binary files /dev/null and b/tests/data/feature-chromafb-063.mat differ diff --git a/tests/data/feature-chromafb-064.mat b/tests/data/feature-chromafb-064.mat new file mode 100644 index 0000000000..12ff2ec262 Binary files /dev/null and b/tests/data/feature-chromafb-064.mat differ diff --git a/tests/data/feature-chromafb-065.mat b/tests/data/feature-chromafb-065.mat new file mode 100644 index 0000000000..1ee1754109 Binary files /dev/null and b/tests/data/feature-chromafb-065.mat differ diff --git a/tests/data/feature-chromafb-066.mat b/tests/data/feature-chromafb-066.mat new file mode 100644 index 0000000000..7c5f54f3df Binary files /dev/null and b/tests/data/feature-chromafb-066.mat differ diff --git a/tests/data/feature-chromafb-067.mat b/tests/data/feature-chromafb-067.mat new file mode 100644 index 0000000000..9046a8329c Binary files /dev/null and b/tests/data/feature-chromafb-067.mat differ diff --git a/tests/data/feature-chromafb-068.mat b/tests/data/feature-chromafb-068.mat new file mode 100644 index 0000000000..6f77345c07 Binary files /dev/null and b/tests/data/feature-chromafb-068.mat differ diff --git a/tests/data/feature-chromafb-069.mat b/tests/data/feature-chromafb-069.mat new file mode 100644 index 0000000000..3bab9ab1cd Binary files /dev/null and b/tests/data/feature-chromafb-069.mat differ diff --git a/tests/data/feature-chromafb-070.mat b/tests/data/feature-chromafb-070.mat new file mode 100644 index 0000000000..0745543c8b Binary files /dev/null and b/tests/data/feature-chromafb-070.mat differ diff --git a/tests/data/feature-chromafb-071.mat b/tests/data/feature-chromafb-071.mat new file mode 100644 index 0000000000..36a2edb3bf Binary files /dev/null and b/tests/data/feature-chromafb-071.mat differ diff --git a/tests/data/feature-chromafb-072.mat b/tests/data/feature-chromafb-072.mat new file mode 100644 index 0000000000..9f12ae58d9 Binary files /dev/null and b/tests/data/feature-chromafb-072.mat differ diff --git a/tests/data/feature-chromafb-073.mat b/tests/data/feature-chromafb-073.mat new file mode 100644 index 0000000000..61b40f664f Binary files /dev/null and b/tests/data/feature-chromafb-073.mat differ diff --git a/tests/data/feature-chromafb-074.mat b/tests/data/feature-chromafb-074.mat new file mode 100644 index 0000000000..3e50db92a5 Binary files /dev/null and b/tests/data/feature-chromafb-074.mat differ diff --git a/tests/data/feature-chromafb-075.mat b/tests/data/feature-chromafb-075.mat new file mode 100644 index 0000000000..b012b2cc45 Binary files /dev/null and b/tests/data/feature-chromafb-075.mat differ diff --git a/tests/data/feature-chromafb-076.mat b/tests/data/feature-chromafb-076.mat new file mode 100644 index 0000000000..c6d5ffb940 Binary files /dev/null and b/tests/data/feature-chromafb-076.mat differ diff --git a/tests/data/feature-chromafb-077.mat b/tests/data/feature-chromafb-077.mat new file mode 100644 index 0000000000..c4a0b0aa7e Binary files /dev/null and b/tests/data/feature-chromafb-077.mat differ diff --git a/tests/data/feature-chromafb-078.mat b/tests/data/feature-chromafb-078.mat new file mode 100644 index 0000000000..6a31ed8315 Binary files /dev/null and b/tests/data/feature-chromafb-078.mat differ diff --git a/tests/data/feature-chromafb-079.mat b/tests/data/feature-chromafb-079.mat new file mode 100644 index 0000000000..2f3245ad5e Binary files /dev/null and b/tests/data/feature-chromafb-079.mat differ diff --git a/tests/data/feature-chromafb-080.mat b/tests/data/feature-chromafb-080.mat new file mode 100644 index 0000000000..2afce9cce4 Binary files /dev/null and b/tests/data/feature-chromafb-080.mat differ diff --git a/tests/data/feature-chromafb-081.mat b/tests/data/feature-chromafb-081.mat new file mode 100644 index 0000000000..f982afa0a9 Binary files /dev/null and b/tests/data/feature-chromafb-081.mat differ diff --git a/tests/data/feature-chromafb-082.mat b/tests/data/feature-chromafb-082.mat new file mode 100644 index 0000000000..7fed506cfe Binary files /dev/null and b/tests/data/feature-chromafb-082.mat differ diff --git a/tests/data/feature-chromafb-083.mat b/tests/data/feature-chromafb-083.mat new file mode 100644 index 0000000000..88e6be230e Binary files /dev/null and b/tests/data/feature-chromafb-083.mat differ diff --git a/tests/data/feature-chromafb-084.mat b/tests/data/feature-chromafb-084.mat new file mode 100644 index 0000000000..82983f7ab0 Binary files /dev/null and b/tests/data/feature-chromafb-084.mat differ diff --git a/tests/data/feature-chromafb-085.mat b/tests/data/feature-chromafb-085.mat new file mode 100644 index 0000000000..6e46ffd542 Binary files /dev/null and b/tests/data/feature-chromafb-085.mat differ diff --git a/tests/data/feature-chromafb-086.mat b/tests/data/feature-chromafb-086.mat new file mode 100644 index 0000000000..4768d14924 Binary files /dev/null and b/tests/data/feature-chromafb-086.mat differ diff --git a/tests/data/feature-chromafb-087.mat b/tests/data/feature-chromafb-087.mat new file mode 100644 index 0000000000..a12d976f9a Binary files /dev/null and b/tests/data/feature-chromafb-087.mat differ diff --git a/tests/data/feature-chromafb-088.mat b/tests/data/feature-chromafb-088.mat new file mode 100644 index 0000000000..30542f4062 Binary files /dev/null and b/tests/data/feature-chromafb-088.mat differ diff --git a/tests/data/feature-chromafb-089.mat b/tests/data/feature-chromafb-089.mat new file mode 100644 index 0000000000..6a96032910 Binary files /dev/null and b/tests/data/feature-chromafb-089.mat differ diff --git a/tests/data/feature-chromafb-090.mat b/tests/data/feature-chromafb-090.mat new file mode 100644 index 0000000000..676ed3d4b7 Binary files /dev/null and b/tests/data/feature-chromafb-090.mat differ diff --git a/tests/data/feature-chromafb-091.mat b/tests/data/feature-chromafb-091.mat new file mode 100644 index 0000000000..7d4b8d1fb0 Binary files /dev/null and b/tests/data/feature-chromafb-091.mat differ diff --git a/tests/data/feature-chromafb-092.mat b/tests/data/feature-chromafb-092.mat new file mode 100644 index 0000000000..6793d7257d Binary files /dev/null and b/tests/data/feature-chromafb-092.mat differ diff --git a/tests/data/feature-chromafb-093.mat b/tests/data/feature-chromafb-093.mat new file mode 100644 index 0000000000..f3241e9db0 Binary files /dev/null and b/tests/data/feature-chromafb-093.mat differ diff --git a/tests/data/feature-chromafb-094.mat b/tests/data/feature-chromafb-094.mat new file mode 100644 index 0000000000..9e35072d15 Binary files /dev/null and b/tests/data/feature-chromafb-094.mat differ diff --git a/tests/data/feature-chromafb-095.mat b/tests/data/feature-chromafb-095.mat new file mode 100644 index 0000000000..02ef88e2bd Binary files /dev/null and b/tests/data/feature-chromafb-095.mat differ diff --git a/tests/data/feature-chromafb-096.mat b/tests/data/feature-chromafb-096.mat new file mode 100644 index 0000000000..4676947777 Binary files /dev/null and b/tests/data/feature-chromafb-096.mat differ diff --git a/tests/data/feature-hz_to_mel-001.mat b/tests/data/feature-hz_to_mel-001.mat new file mode 100644 index 0000000000..b28a523f79 Binary files /dev/null and b/tests/data/feature-hz_to_mel-001.mat differ diff --git a/tests/data/feature-hz_to_mel-002.mat b/tests/data/feature-hz_to_mel-002.mat new file mode 100644 index 0000000000..67a49d4ccd Binary files /dev/null and b/tests/data/feature-hz_to_mel-002.mat differ diff --git a/tests/data/feature-hz_to_mel-003.mat b/tests/data/feature-hz_to_mel-003.mat new file mode 100644 index 0000000000..24adf3ebe1 Binary files /dev/null and b/tests/data/feature-hz_to_mel-003.mat differ diff --git a/tests/data/feature-hz_to_mel-004.mat b/tests/data/feature-hz_to_mel-004.mat new file mode 100644 index 0000000000..82c3cb80f8 Binary files /dev/null and b/tests/data/feature-hz_to_mel-004.mat differ diff --git a/tests/data/feature-hz_to_octs-001.mat b/tests/data/feature-hz_to_octs-001.mat new file mode 100644 index 0000000000..e542b6905f Binary files /dev/null and b/tests/data/feature-hz_to_octs-001.mat differ diff --git a/tests/data/feature-hz_to_octs-002.mat b/tests/data/feature-hz_to_octs-002.mat new file mode 100644 index 0000000000..42f813f0dc Binary files /dev/null and b/tests/data/feature-hz_to_octs-002.mat differ diff --git a/tests/data/feature-mel_to_hz-001.mat b/tests/data/feature-mel_to_hz-001.mat new file mode 100644 index 0000000000..5265abd591 Binary files /dev/null and b/tests/data/feature-mel_to_hz-001.mat differ diff --git a/tests/data/feature-mel_to_hz-002.mat b/tests/data/feature-mel_to_hz-002.mat new file mode 100644 index 0000000000..50d093e70b Binary files /dev/null and b/tests/data/feature-mel_to_hz-002.mat differ diff --git a/tests/data/feature-mel_to_hz-003.mat b/tests/data/feature-mel_to_hz-003.mat new file mode 100644 index 0000000000..302f09ec08 Binary files /dev/null and b/tests/data/feature-mel_to_hz-003.mat differ diff --git a/tests/data/feature-mel_to_hz-004.mat b/tests/data/feature-mel_to_hz-004.mat new file mode 100644 index 0000000000..159a77ee2c Binary files /dev/null and b/tests/data/feature-mel_to_hz-004.mat differ diff --git a/tests/data/feature-melfb-001.mat b/tests/data/feature-melfb-001.mat new file mode 100644 index 0000000000..5ed7c72632 Binary files /dev/null and b/tests/data/feature-melfb-001.mat differ diff --git a/tests/data/feature-melfb-002.mat b/tests/data/feature-melfb-002.mat new file mode 100644 index 0000000000..452064eb13 Binary files /dev/null and b/tests/data/feature-melfb-002.mat differ diff --git a/tests/data/feature-melfb-003.mat b/tests/data/feature-melfb-003.mat new file mode 100644 index 0000000000..17903d6d83 Binary files /dev/null and b/tests/data/feature-melfb-003.mat differ diff --git a/tests/data/feature-melfb-004.mat b/tests/data/feature-melfb-004.mat new file mode 100644 index 0000000000..907c0ddb15 Binary files /dev/null and b/tests/data/feature-melfb-004.mat differ diff --git a/tests/data/feature-melfb-005.mat b/tests/data/feature-melfb-005.mat new file mode 100644 index 0000000000..ccddd1d09a Binary files /dev/null and b/tests/data/feature-melfb-005.mat differ diff --git a/tests/data/feature-melfb-006.mat b/tests/data/feature-melfb-006.mat new file mode 100644 index 0000000000..c15efb7e8a Binary files /dev/null and b/tests/data/feature-melfb-006.mat differ diff --git a/tests/data/feature-melfb-007.mat b/tests/data/feature-melfb-007.mat new file mode 100644 index 0000000000..26c458f45f Binary files /dev/null and b/tests/data/feature-melfb-007.mat differ diff --git a/tests/data/feature-melfb-008.mat b/tests/data/feature-melfb-008.mat new file mode 100644 index 0000000000..d943a16c94 Binary files /dev/null and b/tests/data/feature-melfb-008.mat differ diff --git a/tests/data/feature-melfb-009.mat b/tests/data/feature-melfb-009.mat new file mode 100644 index 0000000000..b5897ea32b Binary files /dev/null and b/tests/data/feature-melfb-009.mat differ diff --git a/tests/data/feature-melfb-010.mat b/tests/data/feature-melfb-010.mat new file mode 100644 index 0000000000..a91cb86399 Binary files /dev/null and b/tests/data/feature-melfb-010.mat differ diff --git a/tests/data/feature-melfb-011.mat b/tests/data/feature-melfb-011.mat new file mode 100644 index 0000000000..7420d766fb Binary files /dev/null and b/tests/data/feature-melfb-011.mat differ diff --git a/tests/data/feature-melfb-012.mat b/tests/data/feature-melfb-012.mat new file mode 100644 index 0000000000..13fa320594 Binary files /dev/null and b/tests/data/feature-melfb-012.mat differ diff --git a/tests/data/feature-melfb-013.mat b/tests/data/feature-melfb-013.mat new file mode 100644 index 0000000000..ac31b94d95 Binary files /dev/null and b/tests/data/feature-melfb-013.mat differ diff --git a/tests/data/feature-melfb-014.mat b/tests/data/feature-melfb-014.mat new file mode 100644 index 0000000000..2723166a54 Binary files /dev/null and b/tests/data/feature-melfb-014.mat differ diff --git a/tests/data/feature-melfb-015.mat b/tests/data/feature-melfb-015.mat new file mode 100644 index 0000000000..4e214b1b63 Binary files /dev/null and b/tests/data/feature-melfb-015.mat differ diff --git a/tests/data/feature-melfb-016.mat b/tests/data/feature-melfb-016.mat new file mode 100644 index 0000000000..103a546d70 Binary files /dev/null and b/tests/data/feature-melfb-016.mat differ diff --git a/tests/data/feature-melfb-017.mat b/tests/data/feature-melfb-017.mat new file mode 100644 index 0000000000..81bbbc60b6 Binary files /dev/null and b/tests/data/feature-melfb-017.mat differ diff --git a/tests/data/feature-melfb-018.mat b/tests/data/feature-melfb-018.mat new file mode 100644 index 0000000000..bd9760d59b Binary files /dev/null and b/tests/data/feature-melfb-018.mat differ diff --git a/tests/data/feature-melfb-019.mat b/tests/data/feature-melfb-019.mat new file mode 100644 index 0000000000..edfec6f462 Binary files /dev/null and b/tests/data/feature-melfb-019.mat differ diff --git a/tests/data/feature-melfb-020.mat b/tests/data/feature-melfb-020.mat new file mode 100644 index 0000000000..8369119ad7 Binary files /dev/null and b/tests/data/feature-melfb-020.mat differ diff --git a/tests/data/feature-melfb-021.mat b/tests/data/feature-melfb-021.mat new file mode 100644 index 0000000000..b32d19671b Binary files /dev/null and b/tests/data/feature-melfb-021.mat differ diff --git a/tests/data/feature-melfb-022.mat b/tests/data/feature-melfb-022.mat new file mode 100644 index 0000000000..c863a0a316 Binary files /dev/null and b/tests/data/feature-melfb-022.mat differ diff --git a/tests/data/feature-melfb-023.mat b/tests/data/feature-melfb-023.mat new file mode 100644 index 0000000000..304714bcfb Binary files /dev/null and b/tests/data/feature-melfb-023.mat differ diff --git a/tests/data/feature-melfb-024.mat b/tests/data/feature-melfb-024.mat new file mode 100644 index 0000000000..d46b6297ee Binary files /dev/null and b/tests/data/feature-melfb-024.mat differ diff --git a/tests/data/feature-melfb-025.mat b/tests/data/feature-melfb-025.mat new file mode 100644 index 0000000000..2b8f2b6e4e Binary files /dev/null and b/tests/data/feature-melfb-025.mat differ diff --git a/tests/data/feature-melfb-026.mat b/tests/data/feature-melfb-026.mat new file mode 100644 index 0000000000..8987251ba9 Binary files /dev/null and b/tests/data/feature-melfb-026.mat differ diff --git a/tests/data/feature-melfb-027.mat b/tests/data/feature-melfb-027.mat new file mode 100644 index 0000000000..b0b8b46741 Binary files /dev/null and b/tests/data/feature-melfb-027.mat differ diff --git a/tests/data/feature-melfb-028.mat b/tests/data/feature-melfb-028.mat new file mode 100644 index 0000000000..ede6ce09fb Binary files /dev/null and b/tests/data/feature-melfb-028.mat differ diff --git a/tests/data/feature-melfb-029.mat b/tests/data/feature-melfb-029.mat new file mode 100644 index 0000000000..3b06374264 Binary files /dev/null and b/tests/data/feature-melfb-029.mat differ diff --git a/tests/data/feature-melfb-030.mat b/tests/data/feature-melfb-030.mat new file mode 100644 index 0000000000..1b24560cd6 Binary files /dev/null and b/tests/data/feature-melfb-030.mat differ diff --git a/tests/data/feature-melfb-031.mat b/tests/data/feature-melfb-031.mat new file mode 100644 index 0000000000..9b1fa7219f Binary files /dev/null and b/tests/data/feature-melfb-031.mat differ diff --git a/tests/data/feature-melfb-032.mat b/tests/data/feature-melfb-032.mat new file mode 100644 index 0000000000..067c1a1fe0 Binary files /dev/null and b/tests/data/feature-melfb-032.mat differ diff --git a/tests/data/feature-melfb-033.mat b/tests/data/feature-melfb-033.mat new file mode 100644 index 0000000000..1d4a3e8649 Binary files /dev/null and b/tests/data/feature-melfb-033.mat differ diff --git a/tests/data/feature-melfb-034.mat b/tests/data/feature-melfb-034.mat new file mode 100644 index 0000000000..bdb8ebc4eb Binary files /dev/null and b/tests/data/feature-melfb-034.mat differ diff --git a/tests/data/feature-melfb-035.mat b/tests/data/feature-melfb-035.mat new file mode 100644 index 0000000000..7c1782eed1 Binary files /dev/null and b/tests/data/feature-melfb-035.mat differ diff --git a/tests/data/feature-melfb-036.mat b/tests/data/feature-melfb-036.mat new file mode 100644 index 0000000000..87f130b30d Binary files /dev/null and b/tests/data/feature-melfb-036.mat differ diff --git a/tests/data/feature-melfb-037.mat b/tests/data/feature-melfb-037.mat new file mode 100644 index 0000000000..d09817c9c7 Binary files /dev/null and b/tests/data/feature-melfb-037.mat differ diff --git a/tests/data/feature-melfb-038.mat b/tests/data/feature-melfb-038.mat new file mode 100644 index 0000000000..8a5188e0c7 Binary files /dev/null and b/tests/data/feature-melfb-038.mat differ diff --git a/tests/data/feature-melfb-039.mat b/tests/data/feature-melfb-039.mat new file mode 100644 index 0000000000..795805463a Binary files /dev/null and b/tests/data/feature-melfb-039.mat differ diff --git a/tests/data/feature-melfb-040.mat b/tests/data/feature-melfb-040.mat new file mode 100644 index 0000000000..e6ddd64a73 Binary files /dev/null and b/tests/data/feature-melfb-040.mat differ diff --git a/tests/data/feature-melfb-041.mat b/tests/data/feature-melfb-041.mat new file mode 100644 index 0000000000..1e0638f716 Binary files /dev/null and b/tests/data/feature-melfb-041.mat differ diff --git a/tests/data/feature-melfb-042.mat b/tests/data/feature-melfb-042.mat new file mode 100644 index 0000000000..35b486caca Binary files /dev/null and b/tests/data/feature-melfb-042.mat differ diff --git a/tests/data/feature-melfb-043.mat b/tests/data/feature-melfb-043.mat new file mode 100644 index 0000000000..b8701b6e73 Binary files /dev/null and b/tests/data/feature-melfb-043.mat differ diff --git a/tests/data/feature-melfb-044.mat b/tests/data/feature-melfb-044.mat new file mode 100644 index 0000000000..299e3a78d6 Binary files /dev/null and b/tests/data/feature-melfb-044.mat differ diff --git a/tests/data/feature-melfb-045.mat b/tests/data/feature-melfb-045.mat new file mode 100644 index 0000000000..1aff0d6297 Binary files /dev/null and b/tests/data/feature-melfb-045.mat differ diff --git a/tests/data/feature-melfb-046.mat b/tests/data/feature-melfb-046.mat new file mode 100644 index 0000000000..b19451c445 Binary files /dev/null and b/tests/data/feature-melfb-046.mat differ diff --git a/tests/data/feature-melfb-047.mat b/tests/data/feature-melfb-047.mat new file mode 100644 index 0000000000..12774c99ca Binary files /dev/null and b/tests/data/feature-melfb-047.mat differ diff --git a/tests/data/feature-melfb-048.mat b/tests/data/feature-melfb-048.mat new file mode 100644 index 0000000000..f6f033b9d0 Binary files /dev/null and b/tests/data/feature-melfb-048.mat differ diff --git a/tests/data/feature-melfb-049.mat b/tests/data/feature-melfb-049.mat new file mode 100644 index 0000000000..722c1065f8 Binary files /dev/null and b/tests/data/feature-melfb-049.mat differ diff --git a/tests/data/feature-melfb-050.mat b/tests/data/feature-melfb-050.mat new file mode 100644 index 0000000000..6c2e009ff7 Binary files /dev/null and b/tests/data/feature-melfb-050.mat differ diff --git a/tests/data/feature-melfb-051.mat b/tests/data/feature-melfb-051.mat new file mode 100644 index 0000000000..ba45dc1a85 Binary files /dev/null and b/tests/data/feature-melfb-051.mat differ diff --git a/tests/data/feature-melfb-052.mat b/tests/data/feature-melfb-052.mat new file mode 100644 index 0000000000..35a8ccae36 Binary files /dev/null and b/tests/data/feature-melfb-052.mat differ diff --git a/tests/data/feature-melfb-053.mat b/tests/data/feature-melfb-053.mat new file mode 100644 index 0000000000..4112a2055a Binary files /dev/null and b/tests/data/feature-melfb-053.mat differ diff --git a/tests/data/feature-melfb-054.mat b/tests/data/feature-melfb-054.mat new file mode 100644 index 0000000000..b3cd14d9f2 Binary files /dev/null and b/tests/data/feature-melfb-054.mat differ diff --git a/tests/data/feature-melfb-055.mat b/tests/data/feature-melfb-055.mat new file mode 100644 index 0000000000..4f012c7011 Binary files /dev/null and b/tests/data/feature-melfb-055.mat differ diff --git a/tests/data/feature-melfb-056.mat b/tests/data/feature-melfb-056.mat new file mode 100644 index 0000000000..7c699ef68d Binary files /dev/null and b/tests/data/feature-melfb-056.mat differ diff --git a/tests/data/feature-melfb-057.mat b/tests/data/feature-melfb-057.mat new file mode 100644 index 0000000000..ea0ccfa9e0 Binary files /dev/null and b/tests/data/feature-melfb-057.mat differ diff --git a/tests/data/feature-melfb-058.mat b/tests/data/feature-melfb-058.mat new file mode 100644 index 0000000000..fc880e9327 Binary files /dev/null and b/tests/data/feature-melfb-058.mat differ diff --git a/tests/data/feature-melfb-059.mat b/tests/data/feature-melfb-059.mat new file mode 100644 index 0000000000..fb667941a3 Binary files /dev/null and b/tests/data/feature-melfb-059.mat differ diff --git a/tests/data/feature-melfb-060.mat b/tests/data/feature-melfb-060.mat new file mode 100644 index 0000000000..a585675e7e Binary files /dev/null and b/tests/data/feature-melfb-060.mat differ diff --git a/tests/data/feature-melfb-061.mat b/tests/data/feature-melfb-061.mat new file mode 100644 index 0000000000..aab9fea6e9 Binary files /dev/null and b/tests/data/feature-melfb-061.mat differ diff --git a/tests/data/feature-melfb-062.mat b/tests/data/feature-melfb-062.mat new file mode 100644 index 0000000000..9f4505ecda Binary files /dev/null and b/tests/data/feature-melfb-062.mat differ diff --git a/tests/data/feature-melfb-063.mat b/tests/data/feature-melfb-063.mat new file mode 100644 index 0000000000..ff284cabf0 Binary files /dev/null and b/tests/data/feature-melfb-063.mat differ diff --git a/tests/data/feature-melfb-064.mat b/tests/data/feature-melfb-064.mat new file mode 100644 index 0000000000..0017fde7f0 Binary files /dev/null and b/tests/data/feature-melfb-064.mat differ diff --git a/tests/data/feature-melfb-065.mat b/tests/data/feature-melfb-065.mat new file mode 100644 index 0000000000..c37603a344 Binary files /dev/null and b/tests/data/feature-melfb-065.mat differ diff --git a/tests/data/feature-melfb-066.mat b/tests/data/feature-melfb-066.mat new file mode 100644 index 0000000000..7d99b52971 Binary files /dev/null and b/tests/data/feature-melfb-066.mat differ diff --git a/tests/data/feature-melfb-067.mat b/tests/data/feature-melfb-067.mat new file mode 100644 index 0000000000..780cc11a63 Binary files /dev/null and b/tests/data/feature-melfb-067.mat differ diff --git a/tests/data/feature-melfb-068.mat b/tests/data/feature-melfb-068.mat new file mode 100644 index 0000000000..3f1f6ac3b7 Binary files /dev/null and b/tests/data/feature-melfb-068.mat differ diff --git a/tests/data/feature-melfb-069.mat b/tests/data/feature-melfb-069.mat new file mode 100644 index 0000000000..3cb871f6f1 Binary files /dev/null and b/tests/data/feature-melfb-069.mat differ diff --git a/tests/data/feature-melfb-070.mat b/tests/data/feature-melfb-070.mat new file mode 100644 index 0000000000..b4529b483e Binary files /dev/null and b/tests/data/feature-melfb-070.mat differ diff --git a/tests/data/feature-melfb-071.mat b/tests/data/feature-melfb-071.mat new file mode 100644 index 0000000000..d16ea61eaf Binary files /dev/null and b/tests/data/feature-melfb-071.mat differ diff --git a/tests/data/feature-melfb-072.mat b/tests/data/feature-melfb-072.mat new file mode 100644 index 0000000000..fed3d1f240 Binary files /dev/null and b/tests/data/feature-melfb-072.mat differ diff --git a/tests/data/feature-melfb-073.mat b/tests/data/feature-melfb-073.mat new file mode 100644 index 0000000000..1c5be78f31 Binary files /dev/null and b/tests/data/feature-melfb-073.mat differ diff --git a/tests/data/feature-melfb-074.mat b/tests/data/feature-melfb-074.mat new file mode 100644 index 0000000000..18bbcd0be0 Binary files /dev/null and b/tests/data/feature-melfb-074.mat differ diff --git a/tests/data/feature-melfb-075.mat b/tests/data/feature-melfb-075.mat new file mode 100644 index 0000000000..d6b86b60c4 Binary files /dev/null and b/tests/data/feature-melfb-075.mat differ diff --git a/tests/data/feature-melfb-076.mat b/tests/data/feature-melfb-076.mat new file mode 100644 index 0000000000..1a0c150c48 Binary files /dev/null and b/tests/data/feature-melfb-076.mat differ diff --git a/tests/data/feature-melfb-077.mat b/tests/data/feature-melfb-077.mat new file mode 100644 index 0000000000..e802717ffb Binary files /dev/null and b/tests/data/feature-melfb-077.mat differ diff --git a/tests/data/feature-melfb-078.mat b/tests/data/feature-melfb-078.mat new file mode 100644 index 0000000000..5a3e12fcb2 Binary files /dev/null and b/tests/data/feature-melfb-078.mat differ diff --git a/tests/data/feature-melfb-079.mat b/tests/data/feature-melfb-079.mat new file mode 100644 index 0000000000..6ccebbeab5 Binary files /dev/null and b/tests/data/feature-melfb-079.mat differ diff --git a/tests/data/feature-melfb-080.mat b/tests/data/feature-melfb-080.mat new file mode 100644 index 0000000000..fc4fc0abff Binary files /dev/null and b/tests/data/feature-melfb-080.mat differ diff --git a/tests/data/feature-melfb-081.mat b/tests/data/feature-melfb-081.mat new file mode 100644 index 0000000000..2882898874 Binary files /dev/null and b/tests/data/feature-melfb-081.mat differ diff --git a/tests/data/feature-melfb-082.mat b/tests/data/feature-melfb-082.mat new file mode 100644 index 0000000000..031392f045 Binary files /dev/null and b/tests/data/feature-melfb-082.mat differ diff --git a/tests/data/feature-melfb-083.mat b/tests/data/feature-melfb-083.mat new file mode 100644 index 0000000000..3015ee1f33 Binary files /dev/null and b/tests/data/feature-melfb-083.mat differ diff --git a/tests/data/feature-melfb-084.mat b/tests/data/feature-melfb-084.mat new file mode 100644 index 0000000000..8c980a9d06 Binary files /dev/null and b/tests/data/feature-melfb-084.mat differ diff --git a/tests/data/feature-melfb-085.mat b/tests/data/feature-melfb-085.mat new file mode 100644 index 0000000000..aa91c5d290 Binary files /dev/null and b/tests/data/feature-melfb-085.mat differ diff --git a/tests/data/feature-melfb-086.mat b/tests/data/feature-melfb-086.mat new file mode 100644 index 0000000000..6c856bbb46 Binary files /dev/null and b/tests/data/feature-melfb-086.mat differ diff --git a/tests/data/feature-melfb-087.mat b/tests/data/feature-melfb-087.mat new file mode 100644 index 0000000000..5724fbbdf1 Binary files /dev/null and b/tests/data/feature-melfb-087.mat differ diff --git a/tests/data/feature-melfb-088.mat b/tests/data/feature-melfb-088.mat new file mode 100644 index 0000000000..ad9f611776 Binary files /dev/null and b/tests/data/feature-melfb-088.mat differ diff --git a/tests/data/feature-melfb-089.mat b/tests/data/feature-melfb-089.mat new file mode 100644 index 0000000000..2d47ee92e2 Binary files /dev/null and b/tests/data/feature-melfb-089.mat differ diff --git a/tests/data/feature-melfb-090.mat b/tests/data/feature-melfb-090.mat new file mode 100644 index 0000000000..b8110ffabf Binary files /dev/null and b/tests/data/feature-melfb-090.mat differ diff --git a/tests/data/feature-melfb-091.mat b/tests/data/feature-melfb-091.mat new file mode 100644 index 0000000000..dc3712cd65 Binary files /dev/null and b/tests/data/feature-melfb-091.mat differ diff --git a/tests/data/feature-melfb-092.mat b/tests/data/feature-melfb-092.mat new file mode 100644 index 0000000000..a460eaad16 Binary files /dev/null and b/tests/data/feature-melfb-092.mat differ diff --git a/tests/data/feature-melfb-093.mat b/tests/data/feature-melfb-093.mat new file mode 100644 index 0000000000..40a24554c6 Binary files /dev/null and b/tests/data/feature-melfb-093.mat differ diff --git a/tests/data/feature-melfb-094.mat b/tests/data/feature-melfb-094.mat new file mode 100644 index 0000000000..d57fdb266a Binary files /dev/null and b/tests/data/feature-melfb-094.mat differ diff --git a/tests/data/feature-melfb-095.mat b/tests/data/feature-melfb-095.mat new file mode 100644 index 0000000000..a6c9d5a49e Binary files /dev/null and b/tests/data/feature-melfb-095.mat differ diff --git a/tests/data/feature-melfb-096.mat b/tests/data/feature-melfb-096.mat new file mode 100644 index 0000000000..b053e71d04 Binary files /dev/null and b/tests/data/feature-melfb-096.mat differ diff --git a/tests/data/feature-melfb-097.mat b/tests/data/feature-melfb-097.mat new file mode 100644 index 0000000000..2460ac29cf Binary files /dev/null and b/tests/data/feature-melfb-097.mat differ diff --git a/tests/data/feature-melfb-098.mat b/tests/data/feature-melfb-098.mat new file mode 100644 index 0000000000..96b83726f6 Binary files /dev/null and b/tests/data/feature-melfb-098.mat differ diff --git a/tests/data/feature-melfb-099.mat b/tests/data/feature-melfb-099.mat new file mode 100644 index 0000000000..90fbaf43b5 Binary files /dev/null and b/tests/data/feature-melfb-099.mat differ diff --git a/tests/data/feature-melfb-100.mat b/tests/data/feature-melfb-100.mat new file mode 100644 index 0000000000..7296c16d79 Binary files /dev/null and b/tests/data/feature-melfb-100.mat differ diff --git a/tests/data/feature-melfb-101.mat b/tests/data/feature-melfb-101.mat new file mode 100644 index 0000000000..fb03ac31c4 Binary files /dev/null and b/tests/data/feature-melfb-101.mat differ diff --git a/tests/data/feature-melfb-102.mat b/tests/data/feature-melfb-102.mat new file mode 100644 index 0000000000..7198214d69 Binary files /dev/null and b/tests/data/feature-melfb-102.mat differ diff --git a/tests/data/feature-melfb-103.mat b/tests/data/feature-melfb-103.mat new file mode 100644 index 0000000000..c426014de9 Binary files /dev/null and b/tests/data/feature-melfb-103.mat differ diff --git a/tests/data/feature-melfb-104.mat b/tests/data/feature-melfb-104.mat new file mode 100644 index 0000000000..dad94a7ee9 Binary files /dev/null and b/tests/data/feature-melfb-104.mat differ diff --git a/tests/data/feature-melfb-105.mat b/tests/data/feature-melfb-105.mat new file mode 100644 index 0000000000..3124a6e6c2 Binary files /dev/null and b/tests/data/feature-melfb-105.mat differ diff --git a/tests/data/feature-melfb-106.mat b/tests/data/feature-melfb-106.mat new file mode 100644 index 0000000000..e88ece8518 Binary files /dev/null and b/tests/data/feature-melfb-106.mat differ diff --git a/tests/data/feature-melfb-107.mat b/tests/data/feature-melfb-107.mat new file mode 100644 index 0000000000..96ab05a8d2 Binary files /dev/null and b/tests/data/feature-melfb-107.mat differ diff --git a/tests/data/feature-melfb-108.mat b/tests/data/feature-melfb-108.mat new file mode 100644 index 0000000000..59e8453ab6 Binary files /dev/null and b/tests/data/feature-melfb-108.mat differ diff --git a/tests/data/feature-melfb-109.mat b/tests/data/feature-melfb-109.mat new file mode 100644 index 0000000000..884dc18d2b Binary files /dev/null and b/tests/data/feature-melfb-109.mat differ diff --git a/tests/data/feature-melfb-110.mat b/tests/data/feature-melfb-110.mat new file mode 100644 index 0000000000..b00959c134 Binary files /dev/null and b/tests/data/feature-melfb-110.mat differ diff --git a/tests/data/feature-melfb-111.mat b/tests/data/feature-melfb-111.mat new file mode 100644 index 0000000000..8835479a7b Binary files /dev/null and b/tests/data/feature-melfb-111.mat differ diff --git a/tests/data/feature-melfb-112.mat b/tests/data/feature-melfb-112.mat new file mode 100644 index 0000000000..1d102d4a9b Binary files /dev/null and b/tests/data/feature-melfb-112.mat differ diff --git a/tests/data/feature-melfb-113.mat b/tests/data/feature-melfb-113.mat new file mode 100644 index 0000000000..c529375978 Binary files /dev/null and b/tests/data/feature-melfb-113.mat differ diff --git a/tests/data/feature-melfb-114.mat b/tests/data/feature-melfb-114.mat new file mode 100644 index 0000000000..ead829fde6 Binary files /dev/null and b/tests/data/feature-melfb-114.mat differ diff --git a/tests/data/feature-melfb-115.mat b/tests/data/feature-melfb-115.mat new file mode 100644 index 0000000000..228357247d Binary files /dev/null and b/tests/data/feature-melfb-115.mat differ diff --git a/tests/data/feature-melfb-116.mat b/tests/data/feature-melfb-116.mat new file mode 100644 index 0000000000..4387aa007b Binary files /dev/null and b/tests/data/feature-melfb-116.mat differ diff --git a/tests/data/feature-melfb-117.mat b/tests/data/feature-melfb-117.mat new file mode 100644 index 0000000000..e0e2525883 Binary files /dev/null and b/tests/data/feature-melfb-117.mat differ diff --git a/tests/data/feature-melfb-118.mat b/tests/data/feature-melfb-118.mat new file mode 100644 index 0000000000..5c734abab3 Binary files /dev/null and b/tests/data/feature-melfb-118.mat differ diff --git a/tests/data/feature-melfb-119.mat b/tests/data/feature-melfb-119.mat new file mode 100644 index 0000000000..b04fe11f24 Binary files /dev/null and b/tests/data/feature-melfb-119.mat differ diff --git a/tests/data/feature-melfb-120.mat b/tests/data/feature-melfb-120.mat new file mode 100644 index 0000000000..26ce90c9de Binary files /dev/null and b/tests/data/feature-melfb-120.mat differ diff --git a/tests/data/feature-melfb-121.mat b/tests/data/feature-melfb-121.mat new file mode 100644 index 0000000000..ae99fe4a86 Binary files /dev/null and b/tests/data/feature-melfb-121.mat differ diff --git a/tests/data/feature-melfb-122.mat b/tests/data/feature-melfb-122.mat new file mode 100644 index 0000000000..a31dfffb70 Binary files /dev/null and b/tests/data/feature-melfb-122.mat differ diff --git a/tests/data/feature-melfb-123.mat b/tests/data/feature-melfb-123.mat new file mode 100644 index 0000000000..2566decfa0 Binary files /dev/null and b/tests/data/feature-melfb-123.mat differ diff --git a/tests/data/feature-melfb-124.mat b/tests/data/feature-melfb-124.mat new file mode 100644 index 0000000000..227e7819e4 Binary files /dev/null and b/tests/data/feature-melfb-124.mat differ diff --git a/tests/data/feature-melfb-125.mat b/tests/data/feature-melfb-125.mat new file mode 100644 index 0000000000..8f1326c144 Binary files /dev/null and b/tests/data/feature-melfb-125.mat differ diff --git a/tests/data/feature-melfb-126.mat b/tests/data/feature-melfb-126.mat new file mode 100644 index 0000000000..583fe2d5aa Binary files /dev/null and b/tests/data/feature-melfb-126.mat differ diff --git a/tests/data/feature-melfb-127.mat b/tests/data/feature-melfb-127.mat new file mode 100644 index 0000000000..370a25ca88 Binary files /dev/null and b/tests/data/feature-melfb-127.mat differ diff --git a/tests/data/feature-melfb-128.mat b/tests/data/feature-melfb-128.mat new file mode 100644 index 0000000000..62638c00e5 Binary files /dev/null and b/tests/data/feature-melfb-128.mat differ diff --git a/tests/data/feature-melfb-129.mat b/tests/data/feature-melfb-129.mat new file mode 100644 index 0000000000..ba57ee70d8 Binary files /dev/null and b/tests/data/feature-melfb-129.mat differ diff --git a/tests/data/feature-melfb-130.mat b/tests/data/feature-melfb-130.mat new file mode 100644 index 0000000000..bc71dea7e7 Binary files /dev/null and b/tests/data/feature-melfb-130.mat differ diff --git a/tests/data/feature-melfb-131.mat b/tests/data/feature-melfb-131.mat new file mode 100644 index 0000000000..254b04be12 Binary files /dev/null and b/tests/data/feature-melfb-131.mat differ diff --git a/tests/data/feature-melfb-132.mat b/tests/data/feature-melfb-132.mat new file mode 100644 index 0000000000..d37ddd57a8 Binary files /dev/null and b/tests/data/feature-melfb-132.mat differ diff --git a/tests/data/feature-melfb-133.mat b/tests/data/feature-melfb-133.mat new file mode 100644 index 0000000000..beefbba545 Binary files /dev/null and b/tests/data/feature-melfb-133.mat differ diff --git a/tests/data/feature-melfb-134.mat b/tests/data/feature-melfb-134.mat new file mode 100644 index 0000000000..de955005f6 Binary files /dev/null and b/tests/data/feature-melfb-134.mat differ diff --git a/tests/data/feature-melfb-135.mat b/tests/data/feature-melfb-135.mat new file mode 100644 index 0000000000..24351a57bb Binary files /dev/null and b/tests/data/feature-melfb-135.mat differ diff --git a/tests/data/feature-melfb-136.mat b/tests/data/feature-melfb-136.mat new file mode 100644 index 0000000000..64f2a15d65 Binary files /dev/null and b/tests/data/feature-melfb-136.mat differ diff --git a/tests/data/feature-melfb-137.mat b/tests/data/feature-melfb-137.mat new file mode 100644 index 0000000000..1d469f35d2 Binary files /dev/null and b/tests/data/feature-melfb-137.mat differ diff --git a/tests/data/feature-melfb-138.mat b/tests/data/feature-melfb-138.mat new file mode 100644 index 0000000000..20f12a9a68 Binary files /dev/null and b/tests/data/feature-melfb-138.mat differ diff --git a/tests/data/feature-melfb-139.mat b/tests/data/feature-melfb-139.mat new file mode 100644 index 0000000000..dbd6550e40 Binary files /dev/null and b/tests/data/feature-melfb-139.mat differ diff --git a/tests/data/feature-melfb-140.mat b/tests/data/feature-melfb-140.mat new file mode 100644 index 0000000000..90267e52cf Binary files /dev/null and b/tests/data/feature-melfb-140.mat differ diff --git a/tests/data/feature-melfb-141.mat b/tests/data/feature-melfb-141.mat new file mode 100644 index 0000000000..dcfb2c7873 Binary files /dev/null and b/tests/data/feature-melfb-141.mat differ diff --git a/tests/data/feature-melfb-142.mat b/tests/data/feature-melfb-142.mat new file mode 100644 index 0000000000..7170ed4b08 Binary files /dev/null and b/tests/data/feature-melfb-142.mat differ diff --git a/tests/data/feature-melfb-143.mat b/tests/data/feature-melfb-143.mat new file mode 100644 index 0000000000..63edf7daf0 Binary files /dev/null and b/tests/data/feature-melfb-143.mat differ diff --git a/tests/data/feature-melfb-144.mat b/tests/data/feature-melfb-144.mat new file mode 100644 index 0000000000..d46534db2f Binary files /dev/null and b/tests/data/feature-melfb-144.mat differ diff --git a/tests/data/feature-tonnetz-chroma.npy b/tests/data/feature-tonnetz-chroma.npy new file mode 100644 index 0000000000..e48ac803f1 Binary files /dev/null and b/tests/data/feature-tonnetz-chroma.npy differ diff --git a/tests/data/feature-tonnetz-msaf.npy b/tests/data/feature-tonnetz-msaf.npy new file mode 100644 index 0000000000..2bb55e97e9 Binary files /dev/null and b/tests/data/feature-tonnetz-msaf.npy differ diff --git a/tests/data/met-bandwidth-001.mat b/tests/data/met-bandwidth-001.mat new file mode 100644 index 0000000000..8c30601e0e Binary files /dev/null and b/tests/data/met-bandwidth-001.mat differ diff --git a/tests/data/met-centroid-001.mat b/tests/data/met-centroid-001.mat new file mode 100644 index 0000000000..2343fb9c7b Binary files /dev/null and b/tests/data/met-centroid-001.mat differ diff --git a/tests/data/met-contrast-001.mat b/tests/data/met-contrast-001.mat new file mode 100644 index 0000000000..ef9360e914 Binary files /dev/null and b/tests/data/met-contrast-001.mat differ diff --git a/tests/data/met-rolloff-001.mat b/tests/data/met-rolloff-001.mat new file mode 100644 index 0000000000..04a05082b6 Binary files /dev/null and b/tests/data/met-rolloff-001.mat differ diff --git a/tests/data/met-rolloff-002.mat b/tests/data/met-rolloff-002.mat new file mode 100644 index 0000000000..459c6713ae Binary files /dev/null and b/tests/data/met-rolloff-002.mat differ diff --git a/tests/data/met-rolloff-003.mat b/tests/data/met-rolloff-003.mat new file mode 100644 index 0000000000..e725bd460c Binary files /dev/null and b/tests/data/met-rolloff-003.mat differ diff --git a/tests/data/test1_22050.wav b/tests/data/test1_22050.wav new file mode 100644 index 0000000000..6a10c3933c Binary files /dev/null and b/tests/data/test1_22050.wav differ diff --git a/tests/data/test1_44100.wav b/tests/data/test1_44100.wav new file mode 100644 index 0000000000..ed8227fd1f Binary files /dev/null and b/tests/data/test1_44100.wav differ diff --git a/tests/data/test2_8000.wav b/tests/data/test2_8000.wav new file mode 100644 index 0000000000..2088d917b9 Binary files /dev/null and b/tests/data/test2_8000.wav differ diff --git a/tests/makeMETdata.m b/tests/makeMETdata.m new file mode 100644 index 0000000000..26c15a8ec6 --- /dev/null +++ b/tests/makeMETdata.m @@ -0,0 +1,140 @@ +function makeMETdata(source_path, output_path) +% testData(source_path, audio_file, output_path) +% source_path = path to METLab code +% output_path = directory to store generated files +% +% CREATED:2015-02-16 12:50:31 by Brian McFee +% Generate the test suite data for spectral features used by +% the MET lab: http://music.ece.drexel.edu/ +% +% spectral_centroid +% spectral_contrast +% spectral_bandwidth +% spectral_rolloff +% +% +% NOTE: +% This script is separate from makeTestData.m because it's designed for use in +% octave, rather than matlab. + + addpath(source_path) + + display('spectral_centroid') + testCentroid(output_path); + + display('spectral_bandwidth') + testBandwidth(output_path); + + display('spectral_contrast') + testContrast(output_path); + + display('spectral_rolloff') + testRolloff(output_path); + + display('Done.') +end + + +function testCentroid(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr] = wavread(wavfile); + y_in = mean(y_in, 2); + + P_NFFT = [512]; + P_HOP = [256]; + + counter = 0; + for nfft = P_NFFT + for hop_length = P_HOP + centroid = spectralCentroid(y_in, sr, nfft, hop_length, nfft); + + counter = counter + 1; + + filename = sprintf('%s/met-centroid-%03d.mat', output_path, counter); + display([' `-- saving ', filename]) + save('-7', filename, 'centroid', 'nfft', 'hop_length', 'wavfile'); + end + end +end + + +function testContrast(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr] = wavread(wavfile); + y_in = mean(y_in, 2); + + P_NFFT = [512]; + P_HOP = [256]; + + counter = 0; + for nfft = P_NFFT + for hop_length = P_HOP + contrast = spectralContrast(y_in, sr, nfft, hop_length, nfft); + + counter = counter + 1; + + filename = sprintf('%s/met-contrast-%03d.mat', output_path, counter); + display([' `-- saving ', filename]) + save('-7', filename, 'contrast', 'nfft', 'hop_length', 'wavfile'); + end + end +end + + +function testRolloff(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr] = wavread(wavfile); + y_in = mean(y_in, 2); + + P_NFFT = [512]; + P_HOP = [256]; + P_PCT = [0.8, 0.9, 0.95]; + + counter = 0; + for nfft = P_NFFT + for hop_length = P_HOP + for pct = P_PCT + rolloff = spectralRolloff(y_in, sr, nfft, hop_length, nfft, pct); + + counter = counter + 1; + + filename = sprintf('%s/met-rolloff-%03d.mat', output_path, counter); + display([' `-- saving ', filename]) + save('-7', filename, 'rolloff', 'nfft', 'hop_length', 'pct', 'wavfile'); + end + end + end +end + + +function testBandwidth(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr] = wavread(wavfile); + y_in = mean(y_in, 2); + + P_NFFT = [512]; + P_HOP = [256]; + + counter = 0; + for nfft = P_NFFT + for hop_length = P_HOP + S = spectrogram(y_in, sr, nfft, hop_length, nfft); + centroid = spectralCentroid(y_in, sr, nfft, hop_length, nfft); + bw = spectralBandwidth(S, centroid, sr); + + counter = counter + 1; + + filename = sprintf('%s/met-bandwidth-%03d.mat', output_path, counter); + display([' `-- saving ', filename]) + save('-7', filename, 'bw', 'S', 'centroid', 'nfft', 'hop_length', 'wavfile'); + end + end +end diff --git a/tests/makeTestData.m b/tests/makeTestData.m index 2595a0849e..ecaa93d08f 100644 --- a/tests/makeTestData.m +++ b/tests/makeTestData.m @@ -1,47 +1,71 @@ -function makeTestData(source_path, output_path) -% makeTestData(source_path, audio_file, output_path) +function testData(source_path, output_path) +% testData(source_path, audio_file, output_path) % source_path = path to DPWE code -% output_ptah = directory to store generated files +% output_path = directory to store generated files % % CREATED:2013-03-08 14:32:21 by Brian McFee -% Generate the test suite data for librosa comparison. +% Generate the test suite data for librosa routines: % -% Validated methods: % hz_to_mel % mel_to_hz % hz_to_octs % -% dctfb -% melfb -% -% localmax -% % stft % istft % +% ifgram +% % load +% resample +% +% melfb +% dctfb +% +% localmax % % Make sure we have the path to DPWE code addpath(source_path); display('hz_to_mel'); - makeTestHz2Mel(output_path); + testHz2Mel(output_path); display('mel_to_hz'); - makeTestMel2Hz(output_path); + testMel2Hz(output_path); display('hz_to_octs'); - makeTestHzToOcts(output_path); + testHzToOcts(output_path); display('load'); - makeTestLoad(output_path); + testLoad(output_path); + + display('stft'); + testSTFT(output_path); + + display('istft'); + testISTFT(output_path); + + + display('ifgram'); + testIFGRAM(output_path); + + display('melfb'); + testMelfb(output_path); + + display('chromafb'); + testChromafb(output_path); + + display('resample'); + testResample(output_path); + + display('beat'); + testBeat(output_path); %% Done! display('Done.'); end -function makeTestHz2Mel(output_path) +function testHz2Mel(output_path) % Test with either a scalar argument or a vector P_HZ = {[440], [2.^(1:13)]}; @@ -62,7 +86,7 @@ function makeTestHz2Mel(output_path) % save the output counter = counter + 1; - filename = sprintf('%s/hz_to_mel-%03d.mat', output_path, counter); + filename = sprintf('%s/feature-hz_to_mel-%03d.mat', output_path, counter); display([' `-- saving ', filename]); save(filename, 'f', 'htk', 'result'); @@ -70,7 +94,7 @@ function makeTestHz2Mel(output_path) end end -function makeTestMel2Hz(output_path) +function testMel2Hz(output_path) % Test with either a scalar argument or a vector P_MELS = {[5], [2.^(-2:9)]}; @@ -91,7 +115,7 @@ function makeTestMel2Hz(output_path) % save the output counter = counter + 1; - filename = sprintf('%s/mel_to_hz-%03d.mat', output_path, counter); + filename = sprintf('%s/feature-mel_to_hz-%03d.mat', output_path, counter); display([' `-- saving ', filename]); save(filename, 'f', 'htk', 'result'); @@ -99,7 +123,7 @@ function makeTestMel2Hz(output_path) end end -function makeTestHzToOcts(output_path) +function testHzToOcts(output_path) % Scalar argument or a vector P_HZ = {[5], [2.^(2:14)]}; @@ -114,35 +138,317 @@ function makeTestHzToOcts(output_path) % save the output counter = counter + 1; - filename = sprintf('%s/hz_to_octs-%03d.mat', output_path, counter); + filename = sprintf('%s/feature-hz_to_octs-%03d.mat', output_path, counter); display([' `-- saving ', filename]); save(filename, 'f', 'result'); end end -function makeTestLoad(output_path) +function testLoad(output_path) % Test: load a wav file % get audio stream (floats) and sample rate % preserve stereo or convert to mono - infile = 'data/test1.wav'; - [y, sr] = wavread(infile); + wavfile = 'data/test1_44100.wav'; + [y, sr] = wavread(wavfile); + y = y'; % Transpose to make python code easier mono = 0; % Stereo output counter = 1; - filename = sprintf('%s/load-%03d.mat', output_path, counter); + filename = sprintf('%s/core-load-%03d.mat', output_path, counter); display([' `-- saving ', filename]); - save(filename, 'infile', 'mono', 'y', 'sr'); + save(filename, 'wavfile', 'mono', 'y', 'sr'); % Mono output counter = 2; mono = 1; - y = mean(y, 2); - filename = sprintf('%s/load-%03d.mat', output_path, counter); + y = mean(y, 1); + filename = sprintf('%s/core-load-%03d.mat', output_path, counter); display([' `-- saving ', filename]); - save(filename, 'infile', 'mono', 'y', 'sr'); + save(filename, 'wavfile', 'mono', 'y', 'sr'); + +end + +function testMelfb(output_path) + + % Test three sample rates + P_SR = [8000, 11025, 22050]; + + % Two FFT lengths + P_NFFT = [256, 512]; + + % Three filter bank sizes + P_NFILTS = [20, 40, 120]; + + % One width + P_WIDTH = [1.0]; + + % F_min + P_FMIN = [0, 512]; + + % F_max + P_FMAX = [2000, inf]; + + % Slaney or HTK mels + P_HTK = [0, 1]; + + % Generate tests + counter = 0; + + for sr = P_SR + for nfft = P_NFFT + for nfilts = P_NFILTS + for width = P_WIDTH + for fmin = P_FMIN + for fmax = P_FMAX + if isinf(fmax) + fmax = sr / 2; + end + for htk = P_HTK + + % Run the function + [wts, frqs] = fft2melmx(nfft, sr, nfilts, width, fmin, fmax, htk, 0); + + % save the output + counter = counter + 1; + + filename = sprintf('%s/feature-melfb-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + + save(filename, ... + 'sr', 'nfft', 'nfilts', 'width', ... + 'fmin', 'fmax', 'htk', 'wts', 'frqs'); + end + end + end + end + end + end + end + +end + +function testResample(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr_in] = wavread(wavfile); + y_in = mean(y_in, 2); % Convert to mono + + % Test a downsample, same SR, and upsample + P_SR = [8000, 22050, 44100]; + + counter = 0; + + for sr_out = P_SR + + y_out = resample(y_in, sr_out, sr_in); + + counter = counter + 1; + filename = sprintf('%s/core-resample-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'y_in', 'sr_in', 'y_out', 'sr_out'); + end +end + +function testSTFT(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y, sr] = wavread(wavfile); + y = mean(y, 2); % Convert to mono + + % Test a couple of different FFT window sizes + P_NFFT = [128, 256, 1024]; + + % And hop sizes + P_HOP = [64, 128, 256]; + + % Note: librosa.stft does not support user-supplied windows, + % so we do not generate tests for this case. + + counter = 0; + + for nfft = P_NFFT + for hop_length = P_HOP + % Test once with no hann window (rectangular) + hann_w = 0; + D = stft(y, nfft, hann_w, hop_length, sr); + + counter = counter + 1; + filename = sprintf('%s/core-stft-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'D', 'sr', 'nfft', 'hann_w', 'hop_length'); + % And again with default hann window (nfft) + hann_w = nfft; + D = stft(y, nfft, hann_w, hop_length, sr); + + counter = counter + 1; + filename = sprintf('%s/core-stft-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'D', 'sr', 'nfft', 'hann_w', 'hop_length'); + end + end +end + +function testIFGRAM(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y, sr] = wavread(wavfile); + y = mean(y, 2); % Convert to mono + + % Test a couple of different FFT window sizes + P_NFFT = [128, 256, 1024]; + + % And window sizes +% P_WIN = [0.25, 0.5, 1.0]; + P_WIN = [1.0]; + + % And hop sizes + P_HOP = [0.25, 0.5, 1.0]; + + % Note: librosa.stft does not support user-supplied windows, + % so we do not generate tests for this case. + + counter = 0; + + for nfft = P_NFFT + for win_ratio = P_WIN + for hop_ratio = P_HOP + % Test once with no hann window (rectangular) + hop_length = round(hop_ratio * nfft); + hann_w = round(win_ratio * nfft); + + [F, D] = ifgram(y, nfft, hann_w, hop_length, sr); + + counter = counter + 1; + filename = sprintf('%s/core-ifgram-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'F', 'D', 'sr', 'nfft', 'hann_w', 'hop_length'); + end + end + end +end + +function testISTFT(output_path) + + wavfile = 'data/test1_22050.wav'; + + [y_in, sr] = wavread(wavfile); + y_in = mean(y_in, 2); % Convert to mono + + % Test a couple of different FFT window sizes + P_NFFT = [128, 256, 1024]; + + % And hop sizes + P_HOP = [64, 128, 256]; + + % Note: librosa.stft does not support user-supplied windows, + % so we do not generate tests for this case. + + counter = 0; + + for nfft = P_NFFT + for hop_length = P_HOP + % Test once with no hann window (rectangular) + hann_w = 0; + D = stft(y_in, nfft, hann_w, hop_length, sr); + Dinv = istft(D, nfft, hann_w, hop_length); + + counter = counter + 1; + filename = sprintf('%s/core-istft-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'D', 'Dinv', 'nfft', 'hann_w', 'hop_length'); + + % And again with default hann window (nfft) + hann_w = nfft; + D = stft(y_in, nfft, hann_w, hop_length, sr); + Dinv = istft(D, nfft, hann_w, hop_length); + + counter = counter + 1; + filename = sprintf('%s/core-istft-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + save(filename, 'D', 'Dinv', 'nfft', 'hann_w', 'hop_length'); + end + end +end + +function testBeat(output_path) + + wavfile = 'data/test2_8000.wav'; + + [y, sr] = wavread(wavfile); + y = mean(y, 2); % Convert to mono + + % Generate the onset envelope first + [t, xcr, D, onsetenv, oesr] = tempo2(y, sr); + + filename = sprintf('%s/beat-onset-000.mat', output_path); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'onsetenv', 'D'); + + filename = sprintf('%s/beat-tempo-000.mat', output_path); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 't', 'onsetenv'); + + [beats, onsetenv_out, D, cumscore] = beat2(onsetenv, oesr); + filename = sprintf('%s/beat-beat-000.mat', output_path); + display([' `-- saving ', filename]); + save(filename, 'wavfile', 'beats', 'onsetenv'); + +end + +function testChromafb(output_path) + + % Test three sample rates + P_SR = [8000, 11025, 22050]; + + % Two FFT lengths + P_NFFT = [256, 512]; + + % Two filter bank sizes + P_NCHROMA = [12, 24]; + + % Two A440s + P_A440 = [435.0, 440.0]; + + % Two center octaves + P_CTROCT = [4.0, 5.0]; + + % Two octave widths + P_OCTWIDTH = [0, 2.0]; + + % Generate tests + counter = 0; + + for sr = P_SR + for nfft = P_NFFT + for nchroma = P_NCHROMA + for a440 = P_A440 + for ctroct = P_CTROCT + for octwidth = P_OCTWIDTH + + % Run the function + wts = fft2chromamx(nfft, nchroma, sr, a440, ctroct, octwidth); + + % save the output + counter = counter + 1; + + filename = sprintf('%s/feature-chromafb-%03d.mat', output_path, counter); + display([' `-- saving ', filename]); + + save(filename, ... + 'sr', 'nfft', 'nchroma', 'a440', ... + 'ctroct', 'octwidth', 'wts'); + end + end + end + end + end + end end diff --git a/tests/mpl_ic.py b/tests/mpl_ic.py new file mode 100644 index 0000000000..9a899563b7 --- /dev/null +++ b/tests/mpl_ic.py @@ -0,0 +1,331 @@ +# CREATED:2015-02-17 14:41:28 by Brian McFee +# this function is lifted wholesale from matploblib v1.4.2, +# and modified so that images are stored explicitly under the tests path + +from __future__ import (absolute_import, division, print_function, + unicode_literals) + +import six + +import functools +import gc +import os +import sys +import shutil +import warnings +import unittest + +import nose +import numpy as np + +import matplotlib.units +from matplotlib import cbook +from matplotlib import ticker +from matplotlib import pyplot as plt +from matplotlib import ft2font +from matplotlib.testing.noseclasses import KnownFailureTest, \ + KnownFailureDidNotFailTest, ImageComparisonFailure +from matplotlib.testing.compare import comparable_formats, compare_images, \ + make_test_filename + + +def knownfailureif(fail_condition, msg=None, known_exception_class=None ): + """ + + Assume a will fail if *fail_condition* is True. *fail_condition* + may also be False or the string 'indeterminate'. + + *msg* is the error message displayed for the test. + + If *known_exception_class* is not None, the failure is only known + if the exception is an instance of this class. (Default = None) + + """ + # based on numpy.testing.dec.knownfailureif + if msg is None: + msg = 'Test known to fail' + def known_fail_decorator(f): + # Local import to avoid a hard nose dependency and only incur the + # import time overhead at actual test-time. + import nose + def failer(*args, **kwargs): + try: + # Always run the test (to generate images). + result = f(*args, **kwargs) + except Exception as err: + if fail_condition: + if known_exception_class is not None: + if not isinstance(err,known_exception_class): + # This is not the expected exception + raise + # (Keep the next ultra-long comment so in shows in console.) + raise KnownFailureTest(msg) # An error here when running nose means that you don't have the matplotlib.testing.noseclasses:KnownFailure plugin in use. + else: + raise + if fail_condition and fail_condition != 'indeterminate': + raise KnownFailureDidNotFailTest(msg) + return result + return nose.tools.make_decorator(f)(failer) + return known_fail_decorator + + +def _do_cleanup(original_units_registry): + plt.close('all') + gc.collect() + + import matplotlib.testing + matplotlib.testing.setup() + + matplotlib.units.registry.clear() + matplotlib.units.registry.update(original_units_registry) + warnings.resetwarnings() # reset any warning filters set in tests + + +class CleanupTest(object): + @classmethod + def setup_class(cls): + cls.original_units_registry = matplotlib.units.registry.copy() + + @classmethod + def teardown_class(cls): + _do_cleanup(cls.original_units_registry) + + def test(self): + self._func() + + +class CleanupTestCase(unittest.TestCase): + '''A wrapper for unittest.TestCase that includes cleanup operations''' + @classmethod + def setUpClass(cls): + import matplotlib.units + cls.original_units_registry = matplotlib.units.registry.copy() + + @classmethod + def tearDownClass(cls): + _do_cleanup(cls.original_units_registry) + + +def cleanup(func): + @functools.wraps(func) + def wrapped_function(*args, **kwargs): + original_units_registry = matplotlib.units.registry.copy() + try: + func(*args, **kwargs) + finally: + _do_cleanup(original_units_registry) + + return wrapped_function + + +def check_freetype_version(ver): + if ver is None: + return True + + from distutils import version + if isinstance(ver, six.string_types): + ver = (ver, ver) + ver = [version.StrictVersion(x) for x in ver] + found = version.StrictVersion(ft2font.__freetype_version__) + + return found >= ver[0] and found <= ver[1] + +class ImageComparisonTest(CleanupTest): + @classmethod + def setup_class(cls): + CleanupTest.setup_class() + + cls._func() + + @staticmethod + def remove_text(figure): + figure.suptitle("") + for ax in figure.get_axes(): + ax.set_title("") + ax.xaxis.set_major_formatter(ticker.NullFormatter()) + ax.xaxis.set_minor_formatter(ticker.NullFormatter()) + ax.yaxis.set_major_formatter(ticker.NullFormatter()) + ax.yaxis.set_minor_formatter(ticker.NullFormatter()) + try: + ax.zaxis.set_major_formatter(ticker.NullFormatter()) + ax.zaxis.set_minor_formatter(ticker.NullFormatter()) + except AttributeError: + pass + + def test(self): + baseline_dir, result_dir = _image_directories(self._func) + + for fignum, baseline in zip(plt.get_fignums(), self._baseline_images): + for extension in self._extensions: + will_fail = not extension in comparable_formats() + if will_fail: + fail_msg = 'Cannot compare %s files on this system' % extension + else: + fail_msg = 'No failure expected' + + orig_expected_fname = os.path.join(baseline_dir, baseline) + '.' + extension + if extension == 'eps' and not os.path.exists(orig_expected_fname): + orig_expected_fname = os.path.join(baseline_dir, baseline) + '.pdf' + expected_fname = make_test_filename(os.path.join( + result_dir, os.path.basename(orig_expected_fname)), 'expected') + actual_fname = os.path.join(result_dir, baseline) + '.' + extension + if os.path.exists(orig_expected_fname): + shutil.copyfile(orig_expected_fname, expected_fname) + else: + will_fail = True + fail_msg = 'Do not have baseline image %s' % expected_fname + + @knownfailureif( + will_fail, fail_msg, + known_exception_class=ImageComparisonFailure) + def do_test(): + figure = plt.figure(fignum) + + if self._remove_text: + self.remove_text(figure) + + figure.savefig(actual_fname, **self._savefig_kwarg) + + plt.close(figure) + + err = compare_images(expected_fname, actual_fname, + self._tol, in_decorator=True) + + try: + if not os.path.exists(expected_fname): + raise ImageComparisonFailure( + 'image does not exist: %s' % expected_fname) + + if err: + raise ImageComparisonFailure( + 'images not close: %(actual)s vs. %(expected)s ' + '(RMS %(rms).3f)'%err) + except ImageComparisonFailure: + if not check_freetype_version(self._freetype_version): + raise KnownFailureTest( + "Mismatched version of freetype. Test requires '%s', you have '%s'" % + (self._freetype_version, ft2font.__freetype_version__)) + raise + + yield (do_test,) + +def image_comparison(baseline_images=None, extensions=None, tol=13, + freetype_version=None, remove_text=False, + savefig_kwarg=None): + """ + call signature:: + + image_comparison(baseline_images=['my_figure'], extensions=None) + + Compare images generated by the test with those specified in + *baseline_images*, which must correspond else an + ImageComparisonFailure exception will be raised. + + Keyword arguments: + + *baseline_images*: list + A list of strings specifying the names of the images generated + by calls to :meth:`matplotlib.figure.savefig`. + + *extensions*: [ None | list ] + + If *None*, default to all supported extensions. + + Otherwise, a list of extensions to test. For example ['png','pdf']. + + *tol*: (default 13) + The RMS threshold above which the test is considered failed. + + *freetype_version*: str or tuple + The expected freetype version or range of versions for this + test to pass. + + *remove_text*: bool + Remove the title and tick text from the figure before + comparison. This does not remove other, more deliberate, + text, such as legends and annotations. + + *savefig_kwarg*: dict + Optional arguments that are passed to the savefig method. + + """ + + if baseline_images is None: + raise ValueError('baseline_images must be specified') + + if extensions is None: + # default extensions to test + extensions = ['png', 'pdf', 'svg'] + + if savefig_kwarg is None: + #default no kwargs to savefig + savefig_kwarg = dict() + + def compare_images_decorator(func): + # We want to run the setup function (the actual test function + # that generates the figure objects) only once for each type + # of output file. The only way to achieve this with nose + # appears to be to create a test class with "setup_class" and + # "teardown_class" methods. Creating a class instance doesn't + # work, so we use type() to actually create a class and fill + # it with the appropriate methods. + name = func.__name__ + # For nose 1.0, we need to rename the test function to + # something without the word "test", or it will be run as + # well, outside of the context of our image comparison test + # generator. + func = staticmethod(func) + func.__get__(1).__name__ = str('_private') + new_class = type( + name, + (ImageComparisonTest,), + {'_func': func, + '_baseline_images': baseline_images, + '_extensions': extensions, + '_tol': tol, + '_freetype_version': freetype_version, + '_remove_text': remove_text, + '_savefig_kwarg': savefig_kwarg}) + + return new_class + return compare_images_decorator + +def _image_directories(func): + """ + Compute the baseline and result image directories for testing *func*. + Create the result directory if it doesn't exist. + """ + module_name = func.__module__ +# mods = module_name.split('.') +# mods.pop(0) # <- will be the name of the package being tested (in + # most cases "matplotlib") +# assert mods.pop(0) == 'tests' +# subdir = os.path.join(*mods) + subdir = module_name + + import imp + def find_dotted_module(module_name, path=None): + """A version of imp which can handle dots in the module name""" + res = None + for sub_mod in module_name.split('.'): + try: + res = file, path, _ = imp.find_module(sub_mod, path) + path = [path] + if file is not None: + file.close() + except ImportError: + # assume namespace package + path = sys.modules[sub_mod].__path__ + res = None, path, None + return res + + mod_file = find_dotted_module(func.__module__)[1] + basedir = os.path.dirname(mod_file) + + baseline_dir = os.path.join(basedir, 'baseline_images', subdir) + result_dir = os.path.abspath(os.path.join('result_images', subdir)) + + if not os.path.exists(result_dir): + cbook.mkdirs(result_dir) + + return baseline_dir, result_dir diff --git a/tests/testLibrosaCore.py b/tests/testLibrosaCore.py deleted file mode 100644 index 166a492888..0000000000 --- a/tests/testLibrosaCore.py +++ /dev/null @@ -1,75 +0,0 @@ -#!/usr/bin/env python -# CREATED:2013-03-08 15:25:18 by Brian McFee -# unit tests for librosa core (__init__.py) -# -# Run me as follows: -# cd tests/ -# nosetests -v - -import librosa -import os, glob -import numpy, scipy.io - -from nose.tools import nottest - -def fileGenerator(pattern): - test_files = glob.glob(pattern) - test_files.sort() - return test_files - -def test_hz_to_mel(): - def __check_hz_to_mel(infile): - DATA = scipy.io.loadmat(infile) - z = librosa.hz_to_mel(DATA['f'], DATA['htk']) - - assert numpy.allclose(z, DATA['result']) - - for infile in fileGenerator('data/*hz_to_mel-*.mat'): - yield (__check_hz_to_mel, infile) - - pass - -def test_mel_to_hz(): - - def __check_mel_to_hz(infile): - DATA = scipy.io.loadmat(infile) - z = librosa.mel_to_hz(DATA['f'], DATA['htk']) - - assert numpy.allclose(z, DATA['result']) - - for infile in fileGenerator('data/*mel_to_hz-*.mat'): - yield (__check_mel_to_hz, infile) - - pass - -def test_hz_to_octs(): - def __check_hz_to_octs(infile): - DATA = scipy.io.loadmat(infile) - z = librosa.hz_to_octs(DATA['f']) - - assert numpy.allclose(z, DATA['result']) - - for infile in fileGenerator('data/*hz_to_octs-*.mat'): - yield (__check_hz_to_octs, infile) - - pass - -def test_load(): - # Note: this does not test resampling. - # That is a separate unit test. - - def __check_load(infile): - DATA = scipy.io.loadmat(infile) - (y, sr) = librosa.load(DATA['infile'][0], target_sr=None, mono=DATA['mono']) - - # Verify that the sample rate is correct - assert sr == DATA['sr'] - - # Transpose here because matlab is row-oriented - assert numpy.allclose(y, DATA['y'].T) - - for infile in fileGenerator('data/*load-*.mat'): - yield (__check_load, infile) - - pass - diff --git a/tests/test_beat.py b/tests/test_beat.py new file mode 100644 index 0000000000..c766a8dffb --- /dev/null +++ b/tests/test_beat.py @@ -0,0 +1,173 @@ +#!/usr/bin/env python +# CREATED:2013-03-11 18:14:30 by Brian McFee +# unit tests for librosa.beat + +from __future__ import print_function +from nose.tools import nottest, raises, eq_ + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +import librosa + +from test_core import files, load + +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +def test_onset_strength(): + + def __test(infile): + DATA = load(infile) + + # Compute onset envelope using the same spectrogram + onsets = librosa.onset.onset_strength(y=None, + sr=8000, + S=DATA['D'], + lag=1, + max_size=1, + center=False, + detrend=True, + aggregate=np.mean) + + assert np.allclose(onsets[1:], DATA['onsetenv'][0]) + + pass + + for infile in files('data/beat-onset-*.mat'): + yield (__test, infile) + + +def test_tempo(): + + def __test(infile): + DATA = load(infile) + + # Estimate tempo from the given onset envelope + tempo = librosa.beat.estimate_tempo(DATA['onsetenv'][0], + sr=8000, + hop_length=32, + start_bpm=120.0) + + assert (np.allclose(tempo, DATA['t'][0, 0]) or + np.allclose(tempo, DATA['t'][0, 1])) + + for infile in files('data/beat-tempo-*.mat'): + yield (__test, infile) + + +@raises(librosa.ParameterError) +def test_beat_no_input(): + + librosa.beat.beat_track(y=None, onset_envelope=None) + + +def test_beat_no_onsets(): + + sr = 22050 + hop_length = 512 + duration = 30 + + onsets = np.zeros(duration * sr // hop_length) + + tempo, beats = librosa.beat.beat_track(onset_envelope=onsets, + sr=sr, + hop_length=hop_length) + + assert np.allclose(tempo, 0) + eq_(len(beats), 0) + + +def test_tempo_no_onsets(): + + sr = 22050 + hop_length = 512 + duration = 30 + onsets = np.zeros(duration * sr // hop_length) + + def __test(start_bpm): + tempo = librosa.beat.estimate_tempo(onsets, sr=sr, + hop_length=hop_length, + start_bpm=start_bpm) + eq_(tempo, start_bpm) + + for start_bpm in [40, 60, 120, 240]: + yield __test, start_bpm + + +def test_beat(): + + y, sr = librosa.load(__EXAMPLE_FILE) + + hop_length = 512 + + onset_env = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop_length) + + def __test(with_audio, with_tempo, start_bpm, bpm, trim, tightness): + + if with_audio: + _y = y + _ons = None + else: + _y = None + _ons = onset_env + + tempo, beats = librosa.beat.beat_track(y=_y, + sr=sr, + onset_envelope=_ons, + hop_length=hop_length, + start_bpm=start_bpm, + tightness=tightness, + trim=trim, + bpm=bpm) + + assert tempo >= 0 + + if len(beats) > 0: + assert beats.min() >= 0 + assert beats.max() <= len(onset_env) + + for with_audio in [False, True]: + for with_tempo in [False, True]: + for trim in [False, True]: + for start_bpm in [-20, 0, 60, 120, 240]: + for bpm in [-20, 0, None, 150, 360]: + for tightness in [0, 100, 10000]: + + if (tightness <= 0 or + (bpm is not None and bpm <= 0) or + (start_bpm is not None and bpm is None and start_bpm <= 0)): + + tf = raises(librosa.ParameterError)(__test) + else: + tf = __test + yield (tf, with_audio, with_tempo, + start_bpm, bpm, trim, tightness) + + +# Beat tracking regression test is no longer enabled due to librosa's +# corrections +@nottest +def deprecated_test_beat(): + + def __test(infile): + + DATA = load(infile) + + (bpm, beats) = librosa.beat.beat_track(y=None, + sr=8000, + hop_length=32, + onset_envelope=DATA['onsetenv'][0]) + + beat_times = librosa.frames_to_time(beats, sr=8000, hop_length=32) + assert np.allclose(beat_times, DATA['beats']) + + for infile in files('data/beat-beat-*.mat'): + yield (__test, infile) diff --git a/tests/test_cache.py b/tests/test_cache.py new file mode 100644 index 0000000000..f55fc1cc93 --- /dev/null +++ b/tests/test_cache.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +# CREATED:2015-02-14 16:20:25 by Brian McFee +# unit tests for librosa cache +'''Tests for librosa.cache''' + +import os +import sys +import tempfile +import numpy as np +import shutil + +import matplotlib +matplotlib.use('Agg') +from nose.tools import with_setup, eq_ + + +# Disable any initial cache settings +for key in ['DIR', 'MMAP', 'COMPRESS', 'VERBOSE']: + try: + os.environ.pop('LIBROSA_CACHE_{:s}'.format(key)) + except KeyError: + pass + + +def cache_construct(): + '''Make a temp directory for the librosa cache''' + cache_dir = tempfile.mkdtemp() + os.environ['LIBROSA_CACHE_DIR'] = cache_dir + + +def cache_teardown(): + '''Blow away the temp directory''' + + cache_dir = os.environ.pop('LIBROSA_CACHE_DIR') + shutil.rmtree(cache_dir) + + +def func(x): + + return np.arange(x) + + +def test_cache_disabled(): + + os.environ.pop('LIBROSA_CACHE_DIR', None) + sys.modules.pop('librosa.cache', None) + import librosa.cache + + func_cache = librosa.cache(func) + + # When there's no cache directory in the environment, + # librosa.cache is a no-op. + eq_(func, func_cache) + + +@with_setup(cache_construct, cache_teardown) +def test_cache_enabled(): + + sys.modules.pop('librosa.cache', None) + import librosa.cache + librosa.cache.clear() + + func_cache = librosa.cache(func) + + # The cache should be active now + assert func_cache != func + + # issue three calls to func + y = func(5) + + for i in range(3): + assert np.allclose(func_cache(5), y) diff --git a/tests/test_constantq.py b/tests/test_constantq.py new file mode 100644 index 0000000000..a53b540ca9 --- /dev/null +++ b/tests/test_constantq.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python +""" +CREATED:2015-03-01 by Eric Battenberg +unit tests for librosa core.constantq + +Run me as follows: + cd tests/ + nosetests -v --with-coverage --cover-package=librosa +""" +from __future__ import division + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +import librosa +import numpy as np + +from nose.tools import raises, eq_ + + +def __test_cqt_size(y, sr, hop_length, fmin, n_bins, bins_per_octave, + tuning, resolution, aggregate, norm, sparsity): + + cqt_output = np.abs(librosa.cqt(y, + sr=sr, + hop_length=hop_length, + fmin=fmin, + n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=resolution, + aggregate=aggregate, + norm=norm, + sparsity=sparsity, + real=False)) + + eq_(cqt_output.shape[0], n_bins) + + return cqt_output + + +def make_signal(sr, duration, fmax='C8'): + ''' Generates a linear sine sweep ''' + + fmin = librosa.note_to_hz('C1') / sr + if fmax is None: + fmax = 0.5 + else: + fmax = librosa.note_to_hz(fmax) / sr + + return np.sin(np.cumsum(2 * np.pi * np.logspace(np.log10(fmin), np.log10(fmax), + num=duration * sr))) + +def test_cqt(): + + sr = 11025 + duration = 5.0 + + y = make_signal(sr, duration) + + # incorrect hop length for a 6-octave analysis + # num_octaves = 6, 2**(6-1) = 32 > 16 + for hop_length in [-1, 0, 16, 63, 65]: + yield (raises(librosa.ParameterError)(__test_cqt_size), y, sr, hop_length, None, 72, + 12, 0.0, 2, None, 1, 0.01) + + # Filters go beyond Nyquist. 500 Hz -> 4 octaves = 8000 Hz > 11000 Hz + yield (raises(librosa.ParameterError)(__test_cqt_size), y, sr, 512, 500, 4 * 12, + 12, 0.0, 2, None, 1, 0.01) + + # Test with fmin near Nyquist + for fmin in [3000, 4800]: + for n_bins in [1, 2]: + for bins_per_octave in [12]: + yield (__test_cqt_size, y, sr, 512, fmin, n_bins, + bins_per_octave, 0.0, 2, None, 1, 0.01) + + # Test for no errors and correct output size + for fmin in [None, librosa.note_to_hz('C2')]: + for n_bins in [1, 12, 24, 48, 72, 74, 76]: + for bins_per_octave in [12, 24]: + for tuning in [None, 0, 0.25]: + for resolution in [1, 2]: + for norm in [1, 2]: + yield (__test_cqt_size, y, sr, 512, fmin, n_bins, + bins_per_octave, tuning, + resolution, None, norm, 0.01) + + +def test_hybrid_cqt(): + # This test verifies that hybrid and full cqt agree down to 1e-4 + # on 99% of bins which are nonzero (> 1e-8) in either representation. + + sr = 11025 + duration = 5.0 + + y = make_signal(sr, duration, None) + + def __test(hop_length, fmin, n_bins, bins_per_octave, + tuning, resolution, norm, sparsity): + + C2 = librosa.hybrid_cqt(y, sr=sr, + hop_length=hop_length, + fmin=fmin, n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, filter_scale=resolution, + norm=norm, + sparsity=sparsity) + + C1 = np.abs(librosa.cqt(y, sr=sr, + hop_length=hop_length, + fmin=fmin, n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, filter_scale=resolution, + norm=norm, + sparsity=sparsity, real=False)) + + eq_(C1.shape, C2.shape) + + # Check for numerical comparability + idx1 = (C1 > 1e-4 * C1.max()) + idx2 = (C2 > 1e-4 * C2.max()) + + perc = 0.99 + + thresh = 1e-3 + + idx = idx1 | idx2 + + assert np.percentile(np.abs(C1[idx] - C2[idx]), + perc) < thresh * max(C1.max(), C2.max()) + + for fmin in [None, librosa.note_to_hz('C2')]: + for n_bins in [1, 12, 24, 48, 72, 74, 76]: + for bins_per_octave in [12, 24]: + for tuning in [None, 0, 0.25]: + for resolution in [1, 2]: + for norm in [1, 2]: + yield (__test, 512, fmin, n_bins, + bins_per_octave, tuning, + resolution, norm, 0.01) + + +def test_cqt_position(): + + # synthesize a two second sine wave at midi note 60 + + sr = 22050 + freq = librosa.midi_to_hz(60) + + y = np.sin(2 * np.pi * freq * np.linspace(0, 2.0, 2 * sr)) + + def __test(note_min): + + C = np.abs(librosa.cqt(y, sr=sr, fmin=librosa.midi_to_hz(note_min), real=False)) + + # Average over time + Cbar = np.median(C, axis=1) + + # Find the peak + idx = np.argmax(Cbar) + + eq_(idx, 60 - note_min) + + # Make sure that the max outside the peak is sufficiently small + Cscale = Cbar / Cbar[idx] + Cscale[idx] = np.nan + assert np.nanmax(Cscale) < 6e-1 + + Cscale[idx-1:idx+2] = np.nan + assert np.nanmax(Cscale) < 5e-2 + + for note_min in [12, 18, 24, 30, 36]: + yield __test, note_min diff --git a/tests/test_core.py b/tests/test_core.py new file mode 100644 index 0000000000..53d3894a9d --- /dev/null +++ b/tests/test_core.py @@ -0,0 +1,892 @@ +#!/usr/bin/env python +# CREATED:2013-03-08 15:25:18 by Brian McFee +# unit tests for librosa core (__init__.py) +# +# Run me as follows: +# cd tests/ +# nosetests -v --with-coverage --cover-package=librosa +# + +from __future__ import print_function +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import librosa +import glob +import numpy as np +import scipy.io +import six +import warnings + +import matplotlib +matplotlib.use('Agg') +from nose.tools import nottest, eq_, raises + + +# -- utilities --# +def files(pattern): + test_files = glob.glob(pattern) + test_files.sort() + return test_files + + +def load(infile): + return scipy.io.loadmat(infile, chars_as_strings=True) + + +def test_load(): + # Note: this does not test resampling. + # That is a separate unit test. + + def __test(infile): + DATA = load(infile) + y, sr = librosa.load(DATA['wavfile'][0], + sr=None, + mono=DATA['mono']) + + # Verify that the sample rate is correct + eq_(sr, DATA['sr']) + + assert np.allclose(y, DATA['y']) + + for infile in files('data/core-load-*.mat'): + yield (__test, infile) + pass + +def test_segment_load(): + + sample_len = 2003 + fs = 44100 + test_file = 'data/test1_44100.wav' + y, sr = librosa.load(test_file, sr=None, mono=False, + offset=0., duration=sample_len/float(fs)) + + eq_(y.shape[-1], sample_len) + + y2, sr = librosa.load(test_file, sr=None, mono=False) + assert np.allclose(y, y2[:, :sample_len]) + + sample_offset = 2048 + y, sr = librosa.load(test_file, sr=None, mono=False, + offset=sample_offset/float(fs), duration=1.0) + + eq_(y.shape[-1], fs) + + y2, sr = librosa.load(test_file, sr=None, mono=False) + assert np.allclose(y, y2[:, sample_offset:sample_offset+fs]) + + +def test_resample_mono(): + + def __test(y, sr_in, sr_out, res_type, fix): + + y2 = librosa.resample(y, sr_in, sr_out, + res_type=res_type, + fix=fix) + + # First, check that the audio is valid + librosa.util.valid_audio(y2, mono=True) + + # If it's a no-op, make sure the signal is untouched + if sr_out == sr_in: + assert np.allclose(y, y2) + + # Check buffer contiguity + assert y2.flags['C_CONTIGUOUS'] + + # Check that we're within one sample of the target length + target_length = y.shape[-1] * sr_out // sr_in + assert np.abs(y2.shape[-1] - target_length) <= 1 + + for infile in ['data/test1_44100.wav', + 'data/test1_22050.wav', + 'data/test2_8000.wav']: + y, sr_in = librosa.load(infile, sr=None, duration=5) + + for sr_out in [8000, 22050]: + for res_type in ['sinc_fastest', 'sinc_best', 'kaiser_best', 'kaiser_fast', 'scipy']: + for fix in [False, True]: + yield (__test, y, sr_in, sr_out, res_type, fix) + + +def test_resample_stereo(): + + def __test(y, sr_in, sr_out, res_type, fix): + + y2 = librosa.resample(y, sr_in, sr_out, + res_type=res_type, + fix=fix) + + # First, check that the audio is valid + librosa.util.valid_audio(y2, mono=False) + + eq_(y2.ndim, y.ndim) + + # If it's a no-op, make sure the signal is untouched + if sr_out == sr_in: + assert np.allclose(y, y2) + + # Check buffer contiguity + assert y2.flags['C_CONTIGUOUS'] + + # Check that we're within one sample of the target length + target_length = y.shape[-1] * sr_out // sr_in + assert np.abs(y2.shape[-1] - target_length) <= 1 + + + y, sr_in = librosa.load('data/test1_44100.wav', mono=False, sr=None, duration=5) + + for sr_out in [8000, 22050]: + for res_type in ['sinc_fastest', 'scipy']: + for fix in [False, True]: + yield __test, y, sr_in, sr_out, res_type, fix + + +def test_resample_scale(): + + def __test(sr_in, sr_out, res_type, y): + + y2 = librosa.resample(y, sr_in, sr_out, + res_type=res_type, + scale=True) + + # First, check that the audio is valid + librosa.util.valid_audio(y2, mono=True) + + n_orig = np.sqrt(np.sum(np.abs(y)**2)) + n_res = np.sqrt(np.sum(np.abs(y2)**2)) + + # If it's a no-op, make sure the signal is untouched + assert np.allclose(n_orig, n_res, atol=1e-2), (n_orig, n_res) + + y, sr_in = librosa.load('data/test1_44100.wav', mono=True, sr=None, duration=5) + + for sr_out in [11025, 22050, 44100]: + for res_type in ['sinc_fastest', 'scipy', 'sinc_best', 'kaiser_best', 'kaiser_fast']: + yield __test, sr_in, sr_out, res_type, y + + +def test_resample_scikitsamplerate(): + warnings.resetwarnings() + warnings.simplefilter('always') + with warnings.catch_warnings(record=True) as out: + + librosa.resample(np.zeros(1000), 1000, 500, res_type='sinc_best') + + assert len(out) > 0 + assert out[0].category is DeprecationWarning + assert 'deprecated' in str(out[0].message).lower() + + +@nottest +def __deprecated_test_resample(): + + def __test(infile, scipy_resample): + DATA = load(infile) + + # load the wav file + (y_in, sr_in) = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + # Resample it to the target rate + y_out = librosa.resample(y_in, DATA['sr_in'], DATA['sr_out'], + scipy_resample=scipy_resample) + + # Are we the same length? + if len(y_out) == len(DATA['y_out']): + # Is the data close? + assert np.allclose(y_out, DATA['y_out']) + elif len(y_out) == len(DATA['y_out']) - 1: + assert (np.allclose(y_out, DATA['y_out'][:-1, 0]) or + np.allclose(y_out, DATA['y_out'][1:, 0])) + elif len(y_out) == len(DATA['y_out']) + 1: + assert (np.allclose(y_out[1:], DATA['y_out']) or + np.allclose(y_out[:-2], DATA['y_out'])) + else: + assert False + pass + + for infile in files('data/core-resample-*.mat'): + for scipy_resample in [False, True]: + yield (__test, infile, scipy_resample) + pass + + +def test_stft(): + + def __test(infile): + DATA = load(infile) + + # Load the file + (y, sr) = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + if DATA['hann_w'][0, 0] == 0: + # Set window to ones, swap back to nfft + window = np.ones + win_length = None + + else: + window = None + win_length = DATA['hann_w'][0, 0] + + # Compute the STFT + D = librosa.stft(y, + n_fft=DATA['nfft'][0, 0].astype(int), + hop_length=DATA['hop_length'][0, 0].astype(int), + win_length=win_length, + window=window, + center=False) + + assert np.allclose(D, DATA['D']) + + for infile in files('data/core-stft-*.mat'): + yield (__test, infile) + + +def test_ifgram(): + + def __test(infile): + DATA = load(infile) + + y, sr = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + # Compute the IFgram + F, D = librosa.ifgram(y, + n_fft=DATA['nfft'][0, 0].astype(int), + hop_length=DATA['hop_length'][0, 0].astype(int), + win_length=DATA['hann_w'][0, 0].astype(int), + sr=DATA['sr'][0, 0].astype(int), + ref_power=0.0, + clip=False, + center=False) + + # D fails to match here because of fftshift() + # assert np.allclose(D, DATA['D']) + assert np.allclose(F, DATA['F'], rtol=1e-1, atol=1e-1) + + for infile in files('data/core-ifgram-*.mat'): + yield (__test, infile) + + +def test_ifgram_matches_stft(): + + y, sr = librosa.load('data/test1_22050.wav') + + def __test(n_fft, hop_length, win_length, center, norm, dtype): + D_stft = librosa.stft(y, n_fft=n_fft, hop_length=hop_length, + win_length=win_length, center=center, + dtype=dtype) + + _, D_ifgram = librosa.ifgram(y, sr, n_fft=n_fft, + hop_length=hop_length, + win_length=win_length, center=center, + norm=norm, dtype=dtype) + + if norm: + # STFT doesn't do window normalization; + # let's just ignore the relative scale to make this easy + D_stft = librosa.util.normalize(D_stft, axis=0) + D_ifgram = librosa.util.normalize(D_ifgram, axis=0) + + assert np.allclose(D_stft, D_ifgram) + + for n_fft in [1024, 2048]: + for hop_length in [None, n_fft // 2, n_fft // 4]: + for win_length in [None, n_fft // 2, n_fft // 4]: + for center in [False, True]: + for norm in [False, True]: + for dtype in [np.complex64, np.complex128]: + yield (__test, n_fft, hop_length, win_length, + center, norm, dtype) + + +def test_ifgram_if(): + + y, sr = librosa.load('data/test1_22050.wav') + + def __test(ref_power, clip): + + F, D = librosa.ifgram(y, sr=sr, ref_power=ref_power, clip=clip) + + if clip: + assert np.all(0 <= F) and np.all(F <= 0.5 * sr) + + assert np.all(np.isfinite(F)) + + for ref_power in [-10, 0.0, 1e-6, np.max]: + for clip in [False, True]: + if six.callable(ref_power) or ref_power >= 0.0: + tf = __test + else: + tf = raises(librosa.ParameterError)(__test) + + yield tf, ref_power, clip + + +def test_magphase(): + + (y, sr) = librosa.load('data/test1_22050.wav') + + D = librosa.stft(y) + + S, P = librosa.magphase(D) + + assert np.allclose(S * P, D) + + +def test_istft_reconstruction(): + from scipy.signal import bartlett, hann, hamming, blackman, blackmanharris + + def __test(x, n_fft, hop_length, window, atol): + S = librosa.core.stft( + x, n_fft=n_fft, hop_length=hop_length, window=window) + x_reconstructed = librosa.core.istft( + S, hop_length=hop_length, window=window) + + L = min(len(x), len(x_reconstructed)) + x = np.resize(x, L) + x_reconstructed = np.resize(x_reconstructed, L) + + # NaN/Inf/-Inf should not happen + assert np.all(np.isfinite(x_reconstructed)) + + # should be almost approximately reconstucted + assert np.allclose(x, x_reconstructed, atol=atol) + + # White noise + np.random.seed(98765) + x1 = np.random.randn(2 ** 15) + + # Sin wave + x2 = np.sin(np.linspace(-np.pi, np.pi, 2 ** 15)) + + # Real music signal + x3, sr = librosa.load('data/test1_44100.wav', sr=None, mono=True) + assert sr == 44100 + + for x, atol in [(x1, 1.0e-6), (x2, 1.0e-7), (x3, 1.0e-7)]: + for window_func in [bartlett, hann, hamming, blackman, blackmanharris]: + for n_fft in [512, 1024, 2048, 4096]: + win = window_func(n_fft, sym=False) + symwin = window_func(n_fft, sym=True) + # tests with pre-computed window fucntions + for hop_length_denom in six.moves.range(2, 9): + hop_length = n_fft // hop_length_denom + yield (__test, x, n_fft, hop_length, win, atol) + yield (__test, x, n_fft, hop_length, symwin, atol) + # also tests with passing widnow function itself + yield (__test, x, n_fft, n_fft // 9, window_func, atol) + + # test with default paramters + x_reconstructed = librosa.core.istft(librosa.core.stft(x)) + L = min(len(x), len(x_reconstructed)) + x = np.resize(x, L) + x_reconstructed = np.resize(x_reconstructed, L) + + assert np.allclose(x, x_reconstructed, atol=atol) + + +def test_load_options(): + + filename = 'data/test1_22050.wav' + + def __test(offset, duration, mono, dtype): + + y, sr = librosa.load(filename, mono=mono, offset=offset, + duration=duration, dtype=dtype) + + if duration is not None: + assert np.allclose(y.shape[-1], int(sr * duration)) + + if mono: + eq_(y.ndim, 1) + else: + # This test file is stereo, so y.ndim should be 2 + eq_(y.ndim, 2) + + # Check the dtype + assert np.issubdtype(y.dtype, dtype) + assert np.issubdtype(dtype, y.dtype) + + for offset in [0, 1, 2]: + for duration in [None, 0, 0.5, 1, 2]: + for mono in [False, True]: + for dtype in [np.float32, np.float64]: + yield __test, offset, duration, mono, dtype + pass + + +def test_get_duration_wav(): + + def __test_audio(filename, mono, sr, duration): + y, sr = librosa.load(filename, sr=sr, mono=mono, duration=duration) + + duration_est = librosa.get_duration(y=y, sr=sr) + + assert np.allclose(duration_est, duration, rtol=1e-3, atol=1e-5) + + def __test_spec(filename, sr, duration, n_fft, hop_length, center): + y, sr = librosa.load(filename, sr=sr, duration=duration) + + S = librosa.stft(y, n_fft=n_fft, hop_length=hop_length, center=center) + + duration_est = librosa.get_duration(S=S, sr=sr, n_fft=n_fft, + hop_length=hop_length, + center=center) + + # We lose a little accuracy in framing without centering, so it's + # not as precise as time-domain duration + assert np.allclose(duration_est, duration, rtol=1e-1, atol=1e-2) + + test_file = 'data/test1_22050.wav' + + for sr in [8000, 11025, 22050]: + for duration in [1.0, 2.5]: + for mono in [False, True]: + yield __test_audio, test_file, mono, sr, duration + + for n_fft in [256, 512, 1024]: + for hop_length in [n_fft // 8, n_fft // 4, n_fft // 2]: + for center in [False, True]: + yield (__test_spec, test_file, sr, + duration, n_fft, hop_length, center) + + +def test_autocorrelate(): + + def __test(y, truth, max_size, axis): + + ac = librosa.autocorrelate(y, max_size=max_size, axis=axis) + + my_slice = [slice(None)] * truth.ndim + if max_size is not None and max_size <= y.shape[axis]: + my_slice[axis] = slice(min(max_size, y.shape[axis])) + + if not np.iscomplexobj(y): + assert not np.iscomplexobj(ac) + + assert np.allclose(ac, truth[my_slice]) + + np.random.seed(128) + + # test with both real and complex signals + for y in [np.random.randn(256, 256), np.exp(1.j * np.random.randn(256, 256))]: + + # Make ground-truth autocorrelations along each axis + truth = [np.asarray([scipy.signal.fftconvolve(yi, yi[::-1].conj(), + mode='full')[len(yi)-1:] for yi in y.T]).T, + np.asarray([scipy.signal.fftconvolve(yi, yi[::-1].conj(), + mode='full')[len(yi)-1:] for yi in y])] + + for axis in [0, 1, -1]: + for max_size in [None, y.shape[axis]//2, y.shape[axis], 2 * y.shape[axis]]: + yield __test, y, truth[axis], max_size, axis + + +def test_to_mono(): + + def __test(filename, mono): + y, sr = librosa.load(filename, mono=mono) + + y_mono = librosa.to_mono(y) + + eq_(y_mono.ndim, 1) + eq_(len(y_mono), y.shape[-1]) + + if mono: + assert np.allclose(y, y_mono) + + filename = 'data/test1_22050.wav' + + for mono in [False, True]: + yield __test, filename, mono + + +def test_zero_crossings(): + + def __test(data, threshold, ref_magnitude, pad, zp): + + zc = librosa.zero_crossings(y=data, + threshold=threshold, + ref_magnitude=ref_magnitude, + pad=pad, + zero_pos=zp) + + idx = np.flatnonzero(zc) + + if pad: + idx = idx[1:] + + for i in idx: + assert np.sign(data[i]) != np.sign(data[i-1]) + + data = np.random.randn(32) + + for threshold in [None, 0, 1e-10]: + for ref_magnitude in [None, 0.1, np.max]: + for pad in [False, True]: + for zero_pos in [False, True]: + + yield __test, data, threshold, ref_magnitude, pad, zero_pos + + +def test_pitch_tuning(): + + def __test(hz, resolution, bins_per_octave, tuning): + + est_tuning = librosa.pitch_tuning(hz, + resolution=resolution, + bins_per_octave=bins_per_octave) + + assert np.abs(tuning - est_tuning) <= resolution + + for resolution in [1e-2, 1e-3]: + for bins_per_octave in [12]: + # Make up some frequencies + for tuning in [-0.5, -0.375, -0.25, 0.0, 0.25, 0.375]: + + note_hz = librosa.midi_to_hz(tuning + np.arange(128)) + + yield __test, note_hz, resolution, bins_per_octave, tuning + + +def test_piptrack_properties(): + + def __test(S, n_fft, hop_length, fmin, fmax, threshold): + + pitches, mags = librosa.core.piptrack(S=S, + n_fft=n_fft, + hop_length=hop_length, + fmin=fmin, + fmax=fmax, + threshold=threshold) + + # Shape tests + eq_(S.shape, pitches.shape) + eq_(S.shape, mags.shape) + + # Make sure all magnitudes are positive + assert np.all(mags >= 0) + + # Check the frequency estimates for bins with non-zero magnitude + idx = (mags > 0) + assert np.all(pitches[idx] >= fmin) + assert np.all(pitches[idx] <= fmax) + + # And everywhere else, pitch should be 0 + assert np.all(pitches[~idx] == 0) + + y, sr = librosa.load('data/test1_22050.wav') + + for n_fft in [2048, 4096]: + for hop_length in [None, n_fft // 4, n_fft // 2]: + S = np.abs(librosa.stft(y, n_fft=n_fft, hop_length=hop_length)) + for fmin in [0, 100]: + for fmax in [4000, 8000, sr // 2]: + for threshold in [0.1, 0.2, 0.5]: + yield __test, S, n_fft, hop_length, fmin, fmax, threshold + + +def test_piptrack_errors(): + + def __test(y, sr, S, n_fft, hop_length, fmin, fmax, threshold): + pitches, mags = librosa.piptrack( + y=y, sr=sr, S=S, n_fft=n_fft, hop_length=hop_length, fmin=fmin, + fmax=fmax, threshold=threshold) + + S = np.asarray([[1, 0, 0]]).T + np.seterr(divide='raise') + yield __test, None, 22050, S, 4096, None, 150.0, 4000.0, 0.1 + + +def test_piptrack(): + + + def __test(S, freq): + pitches, mags = librosa.piptrack(S=S, fmin=100) + + idx = (mags > 0) + + assert len(idx) > 0 + + recovered_pitches = pitches[idx] + + # We should be within one cent of the target + assert np.all(np.abs(np.log2(recovered_pitches) - np.log2(freq)) <= 1e-2) + + + sr = 22050 + duration = 3.0 + + for freq in [110, 220, 440, 880]: + # Generate a sine tone + y = np.sin(2 * np.pi * freq * np.linspace(0, duration, num=duration*sr)) + for n_fft in [1024, 2048, 4096]: + # Using left-aligned frames eliminates reflection artifacts at the boundaries + S = np.abs(librosa.stft(y, n_fft=n_fft, center=False)) + + yield __test, S, freq + + + +def test_estimate_tuning(): + + def __test(target_hz, resolution, bins_per_octave, tuning): + + y = np.sin(2 * np.pi * target_hz * t) + tuning_est = librosa.estimate_tuning(resolution=resolution, + bins_per_octave=bins_per_octave, + y=y, + sr=sr, + n_fft=2048, + fmin=librosa.note_to_hz('C4'), + fmax=librosa.note_to_hz('G#9')) + + # Round to the proper number of decimals + deviation = np.around(np.abs(tuning - tuning_est), + int(-np.log10(resolution))) + + # We'll accept an answer within three bins of the resolution + assert deviation <= 3 * resolution + + for sr in [11025, 22050]: + duration = 5.0 + + t = np.linspace(0, duration, duration * sr) + + for resolution in [1e-2]: + for bins_per_octave in [12]: + # test a null-signal tuning estimate + yield (__test, 0.0, resolution, bins_per_octave, 0.0) + + for center_note in [69, 84, 108]: + for tuning in np.linspace(-0.5, 0.5, 8, endpoint=False): + target_hz = librosa.midi_to_hz(center_note + tuning) + + yield (__test, np.asscalar(target_hz), resolution, + bins_per_octave, tuning) + + +def test__spectrogram(): + + y, sr = librosa.load('data/test1_22050.wav') + + def __test(n_fft, hop_length, power): + + S = np.abs(librosa.stft(y, n_fft=n_fft, hop_length=hop_length))**power + + S_, n_fft_ = librosa.core.spectrum._spectrogram(y=y, S=S, n_fft=n_fft, + hop_length=hop_length, + power=power) + + # First check with all parameters + assert np.allclose(S, S_) + assert np.allclose(n_fft, n_fft_) + + # Then check with only the audio + S_, n_fft_ = librosa.core.spectrum._spectrogram(y=y, n_fft=n_fft, + hop_length=hop_length, + power=power) + assert np.allclose(S, S_) + assert np.allclose(n_fft, n_fft_) + + # And only the spectrogram + S_, n_fft_ = librosa.core.spectrum._spectrogram(S=S, n_fft=n_fft, + hop_length=hop_length, + power=power) + assert np.allclose(S, S_) + assert np.allclose(n_fft, n_fft_) + + # And only the spectrogram with no shape parameters + S_, n_fft_ = librosa.core.spectrum._spectrogram(S=S, power=power) + assert np.allclose(S, S_) + assert np.allclose(n_fft, n_fft_) + + # And only the spectrogram but with incorrect n_fft + S_, n_fft_ = librosa.core.spectrum._spectrogram(S=S, n_fft=2*n_fft, + power=power) + assert np.allclose(S, S_) + assert np.allclose(n_fft, n_fft_) + + for n_fft in [1024, 2048]: + for hop_length in [None, 512]: + for power in [1, 2]: + yield __test, n_fft, hop_length, power + assert librosa.core.spectrum._spectrogram(y) + + +def test_logamplitude(): + + # Fake up some data + def __test(x, ref_power, amin, top_db): + + y = librosa.logamplitude(x, + ref_power=ref_power, + amin=amin, + top_db=top_db) + + assert np.isrealobj(y) + eq_(y.shape, x.shape) + + if top_db is not None: + assert y.min() >= y.max()-top_db + + for n in [1, 2, 10]: + x = np.linspace(0, 2e5, num=n) + phase = np.exp(1.j * x) + + for ref_power in [1.0, np.max]: + for amin in [-1, 0, 1e-10, 1e3]: + for top_db in [None, -10, 0, 40, 80]: + tf = __test + if amin <= 0 or (top_db is not None and top_db < 0): + tf = raises(librosa.ParameterError)(__test) + yield tf, x, ref_power, amin, top_db + yield tf, x * phase, ref_power, amin, top_db + + +def test_clicks(): + + def __test(times, frames, sr, hop_length, click_freq, click_duration, click, length): + + y = librosa.clicks(times=times, + frames=frames, + sr=sr, + hop_length=hop_length, + click_freq=click_freq, + click_duration=click_duration, + click=click, + length=length) + + if times is not None: + nmax = librosa.time_to_samples(times, sr=sr).max() + else: + nmax = librosa.frames_to_samples(frames, hop_length=hop_length).max() + + if length is not None: + assert len(y) == length + elif click is not None: + assert len(y) == nmax + len(click) + + + test_times = np.linspace(0, 10.0, num=5) + + # Bad cases + yield raises(librosa.ParameterError)(__test), None, None, 22050, 512, 1000, 0.1, None, None + yield raises(librosa.ParameterError)(__test), test_times, None, 22050, 512, 1000, 0.1, np.ones((2, 10)), None + yield raises(librosa.ParameterError)(__test), test_times, None, 22050, 512, 1000, 0.1, None, 0 + yield raises(librosa.ParameterError)(__test), test_times, None, 22050, 512, 0, 0.1, None, None + yield raises(librosa.ParameterError)(__test), test_times, None, 22050, 512, 1000, 0, None, None + + for sr in [11025, 22050]: + for hop_length in [512, 1024]: + test_frames = librosa.time_to_frames(test_times, sr=sr, hop_length=hop_length) + + for click in [None, np.ones(sr // 10)]: + + for length in [None, 5 * sr, 15 * sr]: + yield __test, test_times, None, sr, hop_length, 1000, 0.1, click, length + yield __test, None, test_frames, sr, hop_length, 1000, 0.1, click, length + + +def test_fmt_scale(): + # This test constructs a single-cycle cosine wave, applies various axis scalings, + # and tests that the FMT is preserved + + def __test(scale, n_fmt, over_sample, kind, y_orig, y_res, atol): + + # Make sure our signals preserve energy + assert np.allclose(np.sum(y_orig**2), np.sum(y_res**2)) + + # Scale-transform the original + f_orig = librosa.fmt(y_orig, + t_min=0.5, + n_fmt=n_fmt, + over_sample=over_sample, + kind=kind) + + # Force to the same length + n_fmt_res = 2 * len(f_orig) - 2 + + # Scale-transform the new signal to match + f_res = librosa.fmt(y_res, + t_min=scale * 0.5, + n_fmt=n_fmt_res, + over_sample=over_sample, + kind=kind) + + # Due to sampling alignment, we'll get some phase deviation here + # The shape of the spectrum should be approximately preserved though. + assert np.allclose(np.abs(f_orig), np.abs(f_res), atol=atol, rtol=1e-7) + + # Our test signal is a single-cycle sine wave + def f(x): + freq = 1 + return np.sin(2 * np.pi * freq * x) + + bounds = [0, 1.0] + num = 2**8 + + x = np.linspace(bounds[0], bounds[1], num=num, endpoint=False) + + y_orig = f(x) + + atol = {'slinear': 1e-4, 'quadratic': 1e-5, 'cubic': 1e-6} + + for scale in [2, 3./2, 5./4, 9./8]: + + # Scale the time axis + x_res = np.linspace(bounds[0], bounds[1], num=scale * num, endpoint=False) + y_res = f(x_res) + + # Re-normalize the energy to match that of y_orig + y_res /= np.sqrt(scale) + + for kind in ['slinear', 'quadratic', 'cubic']: + for n_fmt in [None, 64, 128, 256, 512]: + for os in [1, 2, 3]: + yield __test, scale, n_fmt, os, kind, y_orig, y_res, atol[kind] + + # Over-sampling with down-scaling gets dicey at the end-points + yield __test, 1./scale, n_fmt, 1, kind, y_res, y_orig, atol[kind] + + +def test_fmt_fail(): + + @raises(librosa.ParameterError) + def __test(t_min, n_fmt, over_sample, y): + librosa.fmt(y, t_min=t_min, n_fmt=n_fmt, over_sample=over_sample) + + y = np.random.randn(256) + + # Test for bad t_min + for t_min in [-1, 0]: + yield __test, t_min, None, 2, y + + # Test for bad n_fmt + for n_fmt in [-1, 0, 1, 2]: + yield __test, 1, n_fmt, 2, y + + # Test for bad over_sample + for over_sample in [-1, 0, 0.5]: + yield __test, 1, None, over_sample, y + + # Test for bad input + y[len(y)//2:] = np.inf + yield __test, 1, None, 2, y + + # Test for insufficient samples + yield __test, 1, None, 1, np.ones(2) + + +def test_fmt_axis(): + + y = np.random.randn(32, 32) + + f1 = librosa.fmt(y, axis=-1) + f2 = librosa.fmt(y.T, axis=0).T + + assert np.allclose(f1, f2) diff --git a/tests/test_decompose.py b/tests/test_decompose.py new file mode 100644 index 0000000000..7f4f364f13 --- /dev/null +++ b/tests/test_decompose.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python +# CREATED: 2013-10-06 22:31:29 by Dawen Liang +# unit tests for librosa.decompose + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +import librosa +import sklearn.decomposition + +from nose.tools import raises + +def test_default_decompose(): + + X = np.array([[1, 2, 3, 4, 5, 6], [1, 1, 1.2, 1, 0.8, 1]]) + + (W, H) = librosa.decompose.decompose(X, random_state=0) + + assert np.allclose(X, W.dot(H), rtol=1e-2, atol=1e-2) + + +def test_given_decompose(): + + D = sklearn.decomposition.NMF(random_state=0) + + X = np.array([[1, 2, 3, 4, 5, 6], [1, 1, 1.2, 1, 0.8, 1]]) + + (W, H) = librosa.decompose.decompose(X, transformer=D) + + assert np.allclose(X, W.dot(H), rtol=1e-2, atol=1e-2) + +def test_decompose_fit(): + + D = sklearn.decomposition.NMF(random_state=0) + + X = np.array([[1, 2, 3, 4, 5, 6], [1, 1, 1.2, 1, 0.8, 1]]) + + # Do a first fit + (W, H) = librosa.decompose.decompose(X, transformer=D, fit=True) + + # Make random data and decompose with the same basis + X = np.random.randn(*X.shape)**2 + (W2, H2) = librosa.decompose.decompose(X, transformer=D, fit=False) + + # Make sure the basis hasn't changed + assert np.allclose(W, W2) + +@raises(librosa.ParameterError) +def test_decompose_fit_false(): + + X = np.array([[1, 2, 3, 4, 5, 6], [1, 1, 1.2, 1, 0.8, 1]]) + (W, H) = librosa.decompose.decompose(X, fit=False) + + +def test_sorted_decompose(): + + X = np.array([[1, 2, 3, 4, 5, 6], [1, 1, 1.2, 1, 0.8, 1]]) + + (W, H) = librosa.decompose.decompose(X, sort=True, random_state=0) + + assert np.allclose(X, W.dot(H), rtol=1e-2, atol=1e-2) + + +def test_real_hpss(): + + # Load an audio signal + y, sr = librosa.load('data/test1_22050.wav') + + D = np.abs(librosa.stft(y)) + + def __hpss_test(w, p, m): + H, P = librosa.decompose.hpss(D, kernel_size=w, power=p, mask=m) + + if m: + assert np.allclose(H + P, np.ones_like(D)) + else: + assert np.allclose(H + P, D) + + for window in [31, (5, 5)]: + for power in [0, 1, 2]: + for mask in [False, True]: + yield __hpss_test, window, power, mask + + +def test_complex_hpss(): + + # Load an audio signal + y, sr = librosa.load('data/test1_22050.wav') + + D = librosa.stft(y) + + H, P = librosa.decompose.hpss(D) + + assert np.allclose(H + P, D) diff --git a/tests/test_display.py b/tests/test_display.py new file mode 100644 index 0000000000..ea7a932d94 --- /dev/null +++ b/tests/test_display.py @@ -0,0 +1,465 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +# CREATED:2015-02-14 22:51:01 by Brian McFee +'''Unit tests for display module''' + + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +import matplotlib +matplotlib.use('Agg') +matplotlib.rcParams.update(matplotlib.rcParamsDefault) +import matplotlib.pyplot as plt + +import librosa +import numpy as np + +import seaborn as sns + +sns.set(style='white') + +from nose.tools import nottest, raises, eq_ +from mpl_ic import image_comparison + +# MPL 1.5 broke things pretty bad. We'll skip image tests for now. +from nose.plugins.skip import SkipTest + +@nottest +def get_spec(y, sr): + + C = np.abs(librosa.cqt(y, sr=sr, real=False)) + return librosa.stft(y), C, sr + + +__EXAMPLE_FILE = 'data/test1_22050.wav' +y, sr = librosa.load(__EXAMPLE_FILE) +S, C, sr = get_spec(y, sr) +S_abs = np.abs(S) +S_signed = np.abs(S) - np.median(np.abs(S)) +S_bin = S_signed > 0 + + +@image_comparison(baseline_images=['complex'], extensions=['png']) +def test_complex_input(): + plt.figure() + librosa.display.specshow(S) + + +@image_comparison(baseline_images=['abs'], extensions=['png']) +def test_abs_input(): + plt.figure() + librosa.display.specshow(S_abs) + + +@image_comparison(baseline_images=['cqt_note'], extensions=['png']) +def test_cqt_note(): + plt.figure() + librosa.display.specshow(C, y_axis='cqt_note') + + +@image_comparison(baseline_images=['cqt_hz'], extensions=['png']) +def test_cqt_hz(): + plt.figure() + librosa.display.specshow(C, y_axis='cqt_hz') + + +@image_comparison(baseline_images=['tempo'], extensions=['png']) +def test_tempo(): + T = librosa.feature.tempogram(y=y, sr=sr) + + plt.figure() + librosa.display.specshow(T, y_axis='tempo') + + +@image_comparison(baseline_images=['tonnetz'], extensions=['png']) +def test_tonnetz(): + plt.figure() + chroma = librosa.feature.chroma_cqt(C=C) + ton = librosa.feature.tonnetz(chroma=chroma) + librosa.display.specshow(ton, y_axis='tonnetz') + + +@image_comparison(baseline_images=['chroma'], extensions=['png']) +def test_chroma(): + plt.figure() + plt.subplot(3, 1, 1) + chr1 = librosa.feature.chroma_stft(S=S_abs**2, sr=sr) + librosa.display.specshow(chr1, y_axis='chroma') + + plt.subplot(3, 1, 2) + chr2 = librosa.feature.chroma_stft(S=S_abs**2, sr=sr, n_chroma=2*12) + librosa.display.specshow(chr2, y_axis='chroma', bins_per_octave=2*12) + + plt.subplot(3, 1, 3) + chr3 = librosa.feature.chroma_stft(S=S_abs**2, sr=sr, n_chroma=3*12) + librosa.display.specshow(chr3, y_axis='chroma', bins_per_octave=3*12) + + +@image_comparison(baseline_images=['double_chroma'], extensions=['png']) +def test_double_chroma(): + plt.figure() + + chr1 = librosa.feature.chroma_stft(S=S_abs**2, sr=sr) + chr1 = np.vstack((chr1, chr1)) + librosa.display.specshow(chr1, y_axis='chroma', bins_per_octave=12) + + +@image_comparison(baseline_images=['x_mel'], extensions=['png']) +def test_x_mel(): + plt.figure() + + M = librosa.feature.melspectrogram(S=S_abs**2) + librosa.display.specshow(M, y_axis='mel') + + +@image_comparison(baseline_images=['y_mel'], extensions=['png']) +def test_y_mel(): + plt.figure() + + M = librosa.feature.melspectrogram(S=S_abs**2) + librosa.display.specshow(M.T, x_axis='mel') + + +@image_comparison(baseline_images=['y_mel_bounded'], extensions=['png']) +def test_y_mel_bounded(): + plt.figure() + + fmin, fmax = 110, 880 + M = librosa.feature.melspectrogram(S=S_abs**2, fmin=fmin, fmax=fmax) + librosa.display.specshow(M, y_axis='mel', fmin=fmin, fmax=fmax) + + +@image_comparison(baseline_images=['x_none_y_linear'], extensions=['png']) +def test_xaxis_none_yaxis_linear(): + plt.figure() + plt.subplot(3, 1, 1) + librosa.display.specshow(S_abs, x_axis='linear') + + plt.subplot(3, 1, 2) + librosa.display.specshow(S_signed, x_axis='linear') + + plt.subplot(3, 1, 3) + librosa.display.specshow(S_bin, x_axis='linear') + + +@image_comparison(baseline_images=['x_none_y_log'], extensions=['png']) +def test_xaxis_none_yaxis_log(): + plt.figure() + + plt.subplot(3, 1, 1) + librosa.display.specshow(S_abs, y_axis='log') + + plt.subplot(3, 1, 2) + librosa.display.specshow(S_signed, y_axis='log') + + plt.subplot(3, 1, 3) + librosa.display.specshow(S_bin, y_axis='log') + + +@image_comparison(baseline_images=['x_none_y_log_khz'], extensions=['png']) +def test_xaxis_none_yaxis_log_khz(): + plt.figure() + librosa.display.specshow(S_abs, y_axis='log', freq_fmt='kHz') + plt.tight_layout() + + +@image_comparison(baseline_images=['x_none_y_log_mhz'], extensions=['png']) +def test_xaxis_none_yaxis_log_mhz(): + plt.figure() + librosa.display.specshow(S_abs, y_axis='log', freq_fmt='mHz') + plt.tight_layout() + +@image_comparison(baseline_images=['x_none_y_log_megahz'], extensions=['png']) +def test_xaxis_none_yaxis_log_megahz(): + plt.figure() + librosa.display.specshow(S_abs, y_axis='log', freq_fmt='MHz') + plt.tight_layout() + + +@image_comparison(baseline_images=['x_none_y_log_ghz'], extensions=['png']) +def test_xaxis_none_yaxis_log_ghz(): + plt.figure() + librosa.display.specshow(S_abs, y_axis='log', freq_fmt='GHz') + plt.tight_layout() + +@raises(librosa.ParameterError) +def test_xaxis_none_yaxis_log_badscale(): + plt.figure() + librosa.display.specshow(S_abs, y_axis='log', freq_fmt='no-scale') + plt.tight_layout() + +@image_comparison(baseline_images=['x_linear_y_none'], extensions=['png']) +def test_xaxis_linear_yaxis_none(): + plt.figure() + + plt.subplot(3, 1, 1) + librosa.display.specshow(S_abs.T, x_axis='linear') + + plt.subplot(3, 1, 2) + librosa.display.specshow(S_signed.T, x_axis='linear') + + plt.subplot(3, 1, 3) + librosa.display.specshow(S_bin.T, x_axis='linear') + + +@image_comparison(baseline_images=['x_log_y_none'], extensions=['png']) +def test_xaxis_log_yaxis_none(): + + plt.figure() + + plt.subplot(3, 1, 1) + librosa.display.specshow(S_abs.T, x_axis='log') + + plt.subplot(3, 1, 2) + librosa.display.specshow(S_signed.T, x_axis='log') + + plt.subplot(3, 1, 3) + librosa.display.specshow(S_bin.T, x_axis='log') + + +@image_comparison(baseline_images=['x_time_y_none'], extensions=['png']) +def test_xaxis_time_yaxis_none(): + + plt.figure() + librosa.display.specshow(S_abs, x_axis='time') + + +@image_comparison(baseline_images=['x_none_y_time'], extensions=['png']) +def test_xaxis_none_yaxis_time(): + + plt.figure() + librosa.display.specshow(S_abs.T, y_axis='time') + + +@image_comparison(baseline_images=['x_frames_y_none'], extensions=['png']) +def test_xaxis_frames_yaxis_none(): + + plt.figure() + librosa.display.specshow(S_abs, x_axis='frames') + + +@image_comparison(baseline_images=['x_none_y_frames'], extensions=['png']) +def test_xaxis_none_yaxis_frames(): + + plt.figure() + librosa.display.specshow(S_abs.T, y_axis='frames') + + +@image_comparison(baseline_images=['x_lag_y_none'], extensions=['png']) +def test_xaxis_lag_yaxis_none(): + + plt.figure() + librosa.display.specshow(S_abs, x_axis='lag') + + +@image_comparison(baseline_images=['x_none_y_lag'], extensions=['png']) +def test_xaxis_time_yaxis_lag(): + + plt.figure() + librosa.display.specshow(S_abs.T, y_axis='lag') + + +@image_comparison(baseline_images=['time_scales_auto'], extensions=['png']) +def test_time_scales_auto(): + + # sr = 22050, hop_length = 512, S.shape[1] = 198 + # 197 * 512 / 22050 ~= 4.6s + plt.figure() + plt.subplot(4, 1, 1) + # sr * 10 -> ms + librosa.display.specshow(S_abs, sr=10 * sr, x_axis='time') + + plt.subplot(4, 1, 2) + # sr -> s + librosa.display.specshow(S_abs, sr=sr, x_axis='time') + + plt.subplot(4, 1, 3) + # sr / 20 -> m + librosa.display.specshow(S_abs, sr=sr // 20, x_axis='time') + + plt.subplot(4, 1, 4) + # sr / (60 * 20) -> h + librosa.display.specshow(S_abs, sr=sr // (60 * 20), x_axis='time') + + +@image_comparison(baseline_images=['time_scales_explicit'], extensions=['png']) +def test_time_scales_explicit(): + + locs = np.linspace(0, S.shape[1], num=5) + times = locs * 512 // sr + + plt.figure() + plt.subplot(4, 1, 1) + librosa.display.specshow(S_abs) + librosa.display.time_ticks(locs, times, time_fmt='ms') + + plt.subplot(4, 1, 2) + librosa.display.specshow(S_abs) + librosa.display.time_ticks(locs, times, time_fmt='s') + + plt.subplot(4, 1, 3) + librosa.display.specshow(S_abs) + librosa.display.time_ticks(locs, times, time_fmt='m') + + plt.subplot(4, 1, 4) + librosa.display.specshow(S_abs) + librosa.display.time_ticks(locs, times, time_fmt='h') + + plt.tight_layout() + + +@image_comparison(baseline_images=['waveplot_mono'], extensions=['png']) +def test_waveplot_mono(): + + plt.figure() + plt.subplot(3, 1, 1) + librosa.display.waveplot(y, sr=sr, max_points=None, x_axis='off') + + plt.subplot(3, 1, 2) + librosa.display.waveplot(y, sr=sr, x_axis='off') + + plt.subplot(3, 1, 3) + librosa.display.waveplot(y, sr=sr, x_axis='time') + + +@image_comparison(baseline_images=['waveplot_stereo'], extensions=['png']) +def test_waveplot_stereo(): + + ys = np.vstack([y[np.newaxis, :], 2 * y[np.newaxis, :]]) + + plt.figure() + librosa.display.waveplot(ys, sr=sr) + + +@raises(librosa.ParameterError) +def test_unknown_wavaxis(): + + plt.figure() + librosa.display.waveplot(y, sr=sr, x_axis='something not in the axis map') + + +@raises(librosa.ParameterError) +def test_waveplot_bad_maxsr(): + + plt.figure() + librosa.display.waveplot(y, sr=sr, max_sr=0) + + +@raises(librosa.ParameterError) +def test_waveplot_bad_maxploints(): + plt.figure() + librosa.display.waveplot(y, sr=sr, max_points=0) + + +def test_unknown_axis(): + + @raises(librosa.ParameterError) + def __test(axis): + kwargs = dict() + kwargs.setdefault(axis, 'something not in the axis map') + plt.figure() + librosa.display.specshow(S_abs, **kwargs) + + yield __test, 'x_axis' + yield __test, 'y_axis' + + +def test_cmap_robust(): + + def __test(use_sns, data): + cmap1 = librosa.display.cmap(data, use_sns=use_sns, robust=False) + cmap2 = librosa.display.cmap(data, use_sns=use_sns, robust=True) + + assert type(cmap1) is type(cmap2) + + if isinstance(cmap1, matplotlib.colors.ListedColormap): + assert np.allclose(cmap1.colors, cmap2.colors) + else: + eq_(cmap1, cmap2) + + # Inputs here are constructed to not need robust sign estimation + for D in [1.0 + S_abs, -(1.0 + S_abs), S_signed, S_bin]: + for use_sns in [False, True]: + yield __test, use_sns, D + + +def test_time_ticks_failure(): + + @raises(librosa.ParameterError) + def __test(locs, times, fmt, axis): + + if times is None: + librosa.display.time_ticks(locs, time_fmt=fmt, axis=axis) + else: + librosa.display.time_ticks(locs, times, time_fmt=fmt, axis=axis) + + locs = np.linspace(0, 100.0) + + # Unknown axis + yield __test, locs, None, None, 'z' + + # Unknown fmt + yield __test, locs, None, 'days', 'x' + + +def test_freq_ticks(): + + def __test(locs, freqs, n_ticks, axis): + + if freqs is None: + args = [locs] + fmax = max(locs) + else: + args = [locs, freqs] + fmax = max(freqs) + + fig = plt.figure() + (ticks, labels), fmt = librosa.display.frequency_ticks(*args, + axis=axis, + n_ticks=n_ticks) + plt.close(fig) + + if n_ticks is None: + n_ticks = len(locs) + + eq_(len(ticks), n_ticks) + eq_(len(labels), n_ticks) + + if fmt == 'mHz': + assert fmax <= 1e1 + elif fmt == 'Hz': + assert fmax <= 1e4 + elif fmt == 'kHz': + assert fmax <= 1e7 + elif fmt == 'MHz': + assert fmax <= 1e10 + elif fmt == 'GHz': + assert fmax > 1e10 + else: + raise ValueError('Incorrect fmt={}'.format(fmt)) + + if axis == 'x': + cls = matplotlib.axis.XTick + elif axis == 'y': + cls = matplotlib.axis.YTick + else: + raise ValueError('Incorrect axis={}'.format(axis)) + + assert all([isinstance(_, cls) for _ in ticks]) + + + for sr in [1e-3, 1e1, 1e3, 1e5, 1e8, 1e12]: + locs = librosa.fft_frequencies(sr=sr, n_fft=32) + + for freqs in [None, locs]: + for n_ticks in [3, 5, None]: + for axis in ['x', 'y']: + yield __test, locs, freqs, n_ticks, axis + + yield raises(librosa.ParameterError)(__test), locs, freqs, n_ticks, 23 + diff --git a/tests/test_effects.py b/tests/test_effects.py new file mode 100644 index 0000000000..b0c3e97e32 --- /dev/null +++ b/tests/test_effects.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +'''Unit tests for the effects module''' + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +from nose.tools import raises, eq_ + +import matplotlib +matplotlib.use('Agg') +import librosa +import numpy as np + +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +def test_time_stretch(): + + def __test(infile, rate): + y, sr = librosa.load(infile, duration=4.0) + ys = librosa.effects.time_stretch(y, rate) + + orig_duration = librosa.get_duration(y, sr=sr) + new_duration = librosa.get_duration(ys, sr=sr) + + # We don't have to be too precise here, since this goes through an STFT + assert np.allclose(orig_duration, rate * new_duration, + rtol=1e-2, atol=1e-3) + + for rate in [0.25, 0.5, 1.0, 2.0, 4.0]: + yield __test, 'data/test1_22050.wav', rate + + for rate in [-1, 0]: + yield raises(librosa.ParameterError)(__test), 'data/test1_22050.wav', rate + + +def test_pitch_shift(): + + def __test(infile, n_steps, bins_per_octave): + y, sr = librosa.load(infile, duration=4.0) + ys = librosa.effects.pitch_shift(y, sr, n_steps, + bins_per_octave=bins_per_octave) + + orig_duration = librosa.get_duration(y, sr=sr) + new_duration = librosa.get_duration(ys, sr=sr) + + # We don't have to be too precise here, since this goes through an STFT + eq_(orig_duration, new_duration) + + for n_steps in np.linspace(-1.5, 1.5, 5): + for bins_per_octave in [12, 24]: + yield __test, 'data/test1_22050.wav', n_steps, bins_per_octave + + for bins_per_octave in [-1, 0]: + yield (raises(librosa.ParameterError)(__test), 'data/test1_22050.wav', + 1, bins_per_octave) + + +def test_remix_mono(): + + # without zc alignment + y = np.asarray([1, 1, -1, -1, 2, 2, -1, -1, 1, 1]) + y_t = np.asarray([-1, -1, -1, -1, 1, 1, 1, 1, 2, 2]) + intervals = np.asarray([[2, 4], + [6, 8], + [0, 2], + [8, 10], + [4, 6]]) + + def __test(y, y_t, intervals, align_zeros): + y_out = librosa.effects.remix(y, intervals, + align_zeros=align_zeros) + assert np.allclose(y_out, y_t) + + for align_zeros in [False, True]: + yield __test, y, y_t, intervals, align_zeros + + +def test_remix_stereo(): + + # without zc alignment + y = np.asarray([1, 1, -1, -1, 2, 2, -1, -1, 1, 1]) + y_t = np.asarray([-1, -1, -1, -1, 1, 1, 1, 1, 2, 2]) + y = np.vstack([y, y]) + y_t = np.vstack([y_t, y_t]) + + intervals = np.asarray([[2, 4], + [6, 8], + [0, 2], + [8, 10], + [4, 6]]) + + def __test(y, y_t, intervals, align_zeros): + y_out = librosa.effects.remix(y, intervals, + align_zeros=align_zeros) + assert np.allclose(y_out, y_t), str(y_out) + + for align_zeros in [False, True]: + yield __test, y, y_t, intervals, align_zeros + + +def test_hpss(): + + y, sr = librosa.load(__EXAMPLE_FILE) + + y_harm, y_perc = librosa.effects.hpss(y) + + # Make sure that the residual energy is generally small + y_residual = y - y_harm - y_perc + + rms_orig = librosa.feature.rmse(y=y) + rms_res = librosa.feature.rmse(y=y_residual) + + assert np.percentile(rms_orig, 0.01) > np.percentile(rms_res, 0.99) + + +def test_percussive(): + + y, sr = librosa.load('data/test1_22050.wav') + + yh1, yp1 = librosa.effects.hpss(y) + + yp2 = librosa.effects.percussive(y) + + assert np.allclose(yp1, yp2) + + +def test_harmonic(): + + y, sr = librosa.load('data/test1_22050.wav') + + yh1, yp1 = librosa.effects.hpss(y) + + yh2 = librosa.effects.harmonic(y) + + assert np.allclose(yh1, yh2) diff --git a/tests/test_failures.py b/tests/test_failures.py new file mode 100644 index 0000000000..4480d43d60 --- /dev/null +++ b/tests/test_failures.py @@ -0,0 +1,128 @@ +#!/usr/bin/env python +# CREATED:2014-12-29 10:52:23 by Brian McFee +# unit tests for ill-formed inputs + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +import librosa +from nose.tools import raises + + +@raises(librosa.ParameterError) +def test_mono_valid_stereo(): + '''valid_audio: mono=True, y.ndim==2''' + y = np.zeros((2, 1000)) + librosa.util.valid_audio(y, mono=True) + + +def test_valid_stereo_or_mono(): + '''valid_audio: mono=False, y.ndim==1''' + y = np.zeros(1000) + librosa.util.valid_audio(y, mono=False) + + +def test_valid_mono(): + '''valid_audio: mono=True, y.ndim==1''' + y = np.zeros(1000) + librosa.util.valid_audio(y, mono=True) + + +def test_valid_stereo(): + '''valid_audio: mono=False, y.ndim==2''' + y = np.zeros((2, 1000)) + librosa.util.valid_audio(y, mono=False) + + +@raises(librosa.ParameterError) +def test_valid_audio_type(): + '''valid_audio: list input''' + y = list(np.zeros(1000)) + librosa.util.valid_audio(y) + + +@raises(librosa.ParameterError) +def test_valid_audio_nan(): + '''valid_audio: NaN''' + y = np.zeros(1000) + y[10] = np.NaN + librosa.util.valid_audio(y) + + +@raises(librosa.ParameterError) +def test_valid_audio_inf(): + '''valid_audio: Inf''' + y = np.zeros(1000) + y[10] = np.inf + librosa.util.valid_audio(y) + + +def test_valid_audio_ndim(): + '''valid_audio: y.ndim > 2''' + + y = np.zeros((3, 10, 10)) + + @raises(librosa.ParameterError) + def __test(mono): + librosa.util.valid_audio(y, mono=mono) + + for mono in [False, True]: + yield __test, mono + + +@raises(librosa.ParameterError) +def test_frame_hop(): + '''frame: hop_length=0''' + y = np.zeros(128) + librosa.util.frame(y, frame_length=10, hop_length=0) + + +@raises(librosa.ParameterError) +def test_frame_discontiguous(): + '''frame: discontiguous input''' + y = np.zeros((128, 2)).T + librosa.util.frame(y[0], frame_length=64, hop_length=64) + + +def test_frame_contiguous(): + '''frame: discontiguous input''' + y = np.zeros((2, 128)) + librosa.util.frame(y[0], frame_length=64, hop_length=64) + + +@raises(librosa.ParameterError) +def test_frame_size(): + '''frame: len(y) == 128, frame_length==256, hop_length=128''' + y = np.zeros(64) + librosa.util.frame(y, frame_length=256, hop_length=128) + + +@raises(librosa.ParameterError) +def test_stft_bad_window(): + + y = np.zeros(22050 * 5) + + n_fft = 2048 + window = np.ones(n_fft // 2) + + librosa.stft(y, n_fft=n_fft, window=window) + + +@raises(librosa.ParameterError) +def test_istft_bad_window(): + + D = np.zeros((1025, 10), dtype=np.complex64) + + n_fft = 2 * (D.shape[0] - 1) + + window = np.ones(n_fft // 2) + + librosa.istft(D, window=window) + diff --git a/tests/test_features.py b/tests/test_features.py new file mode 100644 index 0000000000..e23fe3e3d3 --- /dev/null +++ b/tests/test_features.py @@ -0,0 +1,561 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- + +from __future__ import print_function + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +import matplotlib +matplotlib.use('Agg') +import librosa +import numpy as np +import scipy.signal + +from nose.tools import raises, eq_ + +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +# utils submodule +def test_delta(): + # Note: this test currently only checks first-order differences + # and width=3 filters + + def __test(width, order, axis, x): + # Compare trimmed and untrimmed versions + delta = librosa.feature.delta(x, + width=width, + order=order, + axis=axis, + trim=False) + delta_t = librosa.feature.delta(x, + width=width, + order=order, + axis=axis, + trim=True) + + # Check that trimming matches the expected shape + eq_(x.shape, delta_t.shape) + + # Check that trimming gives the right values in the right places + _s = [slice(None)] * delta.ndim + _s[axis] = slice(- width//2 - x.shape[axis], -(width//2)-1) + delta_retrim = delta[_s] + assert np.allclose(delta_t, delta_retrim) + + # Once we're sufficiently far into the signal (ie beyond half_len) + # (x + delta_t)[t] should approximate x[t+1] if x is actually linear + slice_orig = [slice(None)] * x.ndim + slice_out = [slice(None)] * delta.ndim + slice_orig[axis] = slice(width//2 + 1, -width//2 + 1) + slice_out[axis] = slice(width//2, -width//2) + assert np.allclose((x + delta_t)[slice_out], x[slice_orig]) + + x = np.vstack([np.arange(100.0)] * 3) + + for width in range(-1, 8): + for slope in np.linspace(-2, 2, num=6): + for bias in [-10, 0, 10]: + for order in [0, 1]: + for axis in range(x.ndim): + tf = __test + if width < 3 or np.mod(width, 2) != 1: + tf = raises(librosa.ParameterError)(__test) + if order != 1: + tf = raises(librosa.ParameterError)(__test) + yield tf, width, order, axis, slope * x + bias + + +def test_stack_memory(): + + def __test(data, n_steps, delay): + data_stack = librosa.feature.stack_memory(data, + n_steps=n_steps, + delay=delay) + + # If we're one-dimensional, reshape for testing + if data.ndim == 1: + data = data.reshape((1, -1)) + + d, t = data.shape + + eq_(data_stack.shape[0], n_steps * d) + eq_(data_stack.shape[1], t) + + for i in range(d): + for step in range(1, n_steps): + assert np.allclose(data[i, :- step * delay], + data_stack[step * d + i, step * delay:]) + + for ndim in [1, 2]: + data = np.random.randn(* ([5] * ndim)) + + for n_steps in [-1, 0, 1, 2, 3, 4]: + for delay in [-1, 0, 1, 2, 4]: + tf = __test + if n_steps < 1: + tf = raises(librosa.ParameterError)(__test) + if delay < 1: + tf = raises(librosa.ParameterError)(__test) + yield tf, data, n_steps, delay + + +# spectral submodule +def test_spectral_centroid_synthetic(): + + k = 5 + + def __test(S, freq, sr, n_fft): + cent = librosa.feature.spectral_centroid(S=S, freq=freq) + + if freq is None: + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + + assert np.allclose(cent, freq[k]) + + # construct a fake spectrogram + sr = 22050 + n_fft = 1024 + S = np.zeros((1 + n_fft // 2, 10)) + + S[k, :] = 1.0 + + yield __test, S, None, sr, n_fft + + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + yield __test, S, freq, sr, n_fft + + # And if we modify the frequencies + freq *= 3 + yield __test, S, freq, sr, n_fft + + # Or if we make up random frequencies for each frame + freq = np.random.randn(*S.shape) + yield __test, S, freq, sr, n_fft + + +def test_spectral_centroid_errors(): + + @raises(librosa.ParameterError) + def __test(S): + librosa.feature.spectral_centroid(S=S) + + S = - np.ones((513, 10)) + yield __test, S + + S = - np.ones((513, 10)) * 1.j + yield __test, S + + +def test_spectral_centroid_empty(): + + def __test(y, sr, S): + cent = librosa.feature.spectral_centroid(y=y, sr=sr, S=S) + assert not np.any(cent) + + sr = 22050 + y = np.zeros(3 * sr) + yield __test, y, sr, None + + S = np.zeros((1025, 10)) + yield __test, None, sr, S + + +def test_spectral_bandwidth_synthetic(): + # This test ensures that a signal confined to a single frequency bin + # always achieves 0 bandwidth + k = 5 + + def __test(S, freq, sr, n_fft, norm, p): + bw = librosa.feature.spectral_bandwidth(S=S, freq=freq, norm=norm, p=p) + + assert not np.any(bw) + + # construct a fake spectrogram + sr = 22050 + n_fft = 1024 + S = np.zeros((1 + n_fft // 2, 10)) + S[k, :] = 1.0 + + for norm in [False, True]: + for p in [1, 2]: + # With vanilla frequencies + yield __test, S, None, sr, n_fft, norm, p + + # With explicit frequencies + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + yield __test, S, freq, sr, n_fft, norm, p + + # And if we modify the frequencies + freq = 3 * librosa.fft_frequencies(sr=sr, n_fft=n_fft) + yield __test, S, freq, sr, n_fft, norm, p + + # Or if we make up random frequencies for each frame + freq = np.random.randn(*S.shape) + yield __test, S, freq, sr, n_fft, norm, p + + +def test_spectral_bandwidth_errors(): + + @raises(librosa.ParameterError) + def __test(S): + librosa.feature.spectral_bandwidth(S=S) + + S = - np.ones((513, 10)) + yield __test, S + + S = - np.ones((513, 10)) * 1.j + yield __test, S + + +def test_spectral_rolloff_synthetic(): + + sr = 22050 + n_fft = 2048 + + def __test(S, freq, pct): + + rolloff = librosa.feature.spectral_rolloff(S=S, sr=sr, freq=freq, + roll_percent=pct) + + if freq is None: + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + + idx = np.floor(pct * freq.shape[0]).astype(int) + assert np.allclose(rolloff, freq[idx]) + + S = np.ones((1 + n_fft // 2, 10)) + + for pct in [0.25, 0.5, 0.95]: + # Implicit frequencies + yield __test, S, None, pct + + # Explicit frequencies + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + yield __test, S, freq, pct + + # And time-varying frequencies + freq = np.cumsum(np.abs(np.random.randn(*S.shape)), axis=0) + yield __test, S, freq, pct + + +def test_spectral_rolloff_errors(): + + @raises(librosa.ParameterError) + def __test(S, p): + librosa.feature.spectral_rolloff(S=S, roll_percent=p) + + S = - np.ones((513, 10)) + yield __test, S, 0.95 + + S = - np.ones((513, 10)) * 1.j + yield __test, S, 0.95 + + S = np.ones((513, 10)) + yield __test, S, -1 + + S = np.ones((513, 10)) + yield __test, S, 2 + + +def test_spectral_contrast_log(): + # We already have a regression test for linear energy difference + # This test just does a sanity-check on the log-scaled version + + y, sr = librosa.load(__EXAMPLE_FILE) + + contrast = librosa.feature.spectral_contrast(y=y, sr=sr, linear=False) + + assert not np.any(contrast < 0) + + +def test_spectral_contrast_errors(): + + @raises(librosa.ParameterError) + def __test(S, freq, fmin, n_bands, quantile): + librosa.feature.spectral_contrast(S=S, + freq=freq, + fmin=fmin, + n_bands=n_bands, + quantile=quantile) + + S = np.ones((1025, 10)) + + # ill-shaped frequency set: scalar + yield __test, S, 0, 200, 6, 0.02 + + # ill-shaped frequency set: wrong-length vector + yield __test, S, np.zeros((S.shape[0]+1,)), 200, 6, 0.02 + + # ill-shaped frequency set: matrix + yield __test, S, np.zeros(S.shape), 200, 6, 0.02 + + # negative fmin + yield __test, S, None, -1, 6, 0.02 + + # zero fmin + yield __test, S, None, 0, 6, 0.02 + + # negative n_bands + yield __test, S, None, 200, -1, 0.02 + + # bad quantile + yield __test, S, None, 200, 6, -1 + + # bad quantile + yield __test, S, None, 200, 6, 2 + + +def test_rmse(): + + def __test(n): + S = np.ones((n, 5)) + + # RMSE of an all-ones band is 1 + rmse = librosa.feature.rmse(S=S) + + assert np.allclose(rmse, np.ones_like(rmse)) + + for n in range(10, 100, 10): + yield __test, n + + +def test_zcr_synthetic(): + + def __test_zcr(rate, y, frame_length, hop_length, center): + zcr = librosa.feature.zero_crossing_rate(y, + frame_length=frame_length, + hop_length=hop_length, + center=center) + + # We don't care too much about the edges if there's padding + if center: + zcr = zcr[:, frame_length//2:-frame_length//2] + + # We'll allow 1% relative error + assert np.allclose(zcr, rate, rtol=1e-2) + + sr = 16384 + for period in [32, 16, 8, 4, 2]: + y = np.ones(sr) + y[::period] = -1 + # Every sign flip induces two crossings + rate = 2./period + # 1+2**k so that we get both sides of the last crossing + for frame_length in [513, 2049]: + for hop_length in [128, 256]: + for center in [False, True]: + yield __test_zcr, rate, y, frame_length, hop_length, center + + +def test_poly_features_synthetic(): + + sr = 22050 + n_fft = 2048 + + def __test(S, coeffs, freq): + + order = coeffs.shape[0] - 1 + p = librosa.feature.poly_features(S=S, sr=sr, n_fft=n_fft, + order=order, freq=freq) + + for i in range(S.shape[-1]): + assert np.allclose(coeffs, p[::-1, i].squeeze()) + + def __make_data(coeffs, freq): + S = np.zeros_like(freq) + for i, c in enumerate(coeffs): + S = S + c * freq**i + + S = S.reshape((freq.shape[0], -1)) + return S + + for order in range(1, 3): + freq = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + coeffs = np.atleast_1d(np.arange(1, 1+order)) + + # First test: vanilla + S = __make_data(coeffs, freq) + yield __test, S, coeffs, None + + # And with explicit frequencies + yield __test, S, coeffs, freq + + # And with alternate frequencies + freq = freq**2.0 + S = __make_data(coeffs, freq) + yield __test, S, coeffs, freq + + # And multi-dimensional + freq = np.cumsum(np.abs(np.random.randn(1 + n_fft//2, 2)), axis=0) + S = __make_data(coeffs, freq) + yield __test, S, coeffs, freq + + +def test_tonnetz(): + y, sr = librosa.load(librosa.util.example_audio_file()) + tonnetz_chroma = np.load("data/feature-tonnetz-chroma.npy") + tonnetz_msaf = np.load("data/feature-tonnetz-msaf.npy") + + # Use cqt chroma + def __audio(): + tonnetz = librosa.feature.tonnetz(y=y, sr=sr) + assert tonnetz.shape[0] == 6 + + # Use pre-computed chroma + def __stft(): + tonnetz = librosa.feature.tonnetz(chroma=tonnetz_chroma) + assert tonnetz.shape[1] == tonnetz_chroma.shape[1] + assert tonnetz.shape[0] == 6 + assert np.allclose(tonnetz_msaf, tonnetz) + + def __cqt(): + # Use high resolution cqt chroma + chroma_cqt = librosa.feature.chroma_cqt(y=y, sr=sr, n_chroma=24) + tonnetz = librosa.feature.tonnetz(chroma=chroma_cqt) + assert tonnetz.shape[1] == chroma_cqt.shape[1] + assert tonnetz.shape[0] == 6 + # Using stft chroma won't generally match cqt chroma + # skip the equivalence check + + # Call the function with not enough parameters + yield (raises(librosa.ParameterError)(librosa.feature.tonnetz)) + yield __audio + yield __stft + yield __cqt + + +def test_tempogram_fail(): + + @raises(librosa.ParameterError) + def __test(y, sr, onset_envelope, hop_length, win_length, center, window, norm): + + librosa.feature.tempogram(y=y, + sr=sr, + onset_envelope=onset_envelope, + hop_length=hop_length, + win_length=win_length, + center=center, + window=window, + norm=norm) + + sr = 22050 + hop_length = 512 + duration = 10 + + y = np.zeros(duration * sr) + + # Fail when no input is provided + yield __test, None, sr, None, hop_length, 384, True, None, np.inf + + # Fail when win_length is too small + for win_length in [-384, -1, 0]: + yield __test, y, sr, None, hop_length, win_length, True, None, np.inf + + # Fail when len(window) != win_length + yield __test, y, sr, None, hop_length, 384, True, np.ones(win_length + 1), np.inf + + +def test_tempogram_audio(): + + def __test(y, sr, oenv, hop_length): + + # Get the tempogram from audio + t1 = librosa.feature.tempogram(y=y, sr=sr, + onset_envelope=None, + hop_length=hop_length) + + # Get the tempogram from oenv + t2 = librosa.feature.tempogram(y=None, sr=sr, + onset_envelope=oenv, + hop_length=hop_length) + + # Make sure it works when both are provided + t3 = librosa.feature.tempogram(y=y, sr=sr, + onset_envelope=oenv, + hop_length=hop_length) + + # And that oenv overrides y + t4 = librosa.feature.tempogram(y=0 * y, sr=sr, + onset_envelope=oenv, + hop_length=hop_length) + + assert np.allclose(t1, t2) + assert np.allclose(t1, t3) + assert np.allclose(t1, t4) + + y, sr = librosa.load(__EXAMPLE_FILE) + + for hop_length in [512, 1024]: + oenv = librosa.onset.onset_strength(y=y, + sr=sr, + hop_length=hop_length) + + yield __test, y, sr, oenv, hop_length + + +def test_tempogram_odf(): + + sr = 22050 + hop_length = 512 + duration = 8 + + def __test_equiv(tempo, center): + odf = np.zeros(duration * sr // hop_length) + spacing = sr * 60. // (hop_length * tempo) + odf[::int(spacing)] = 1 + + odf_ac = librosa.autocorrelate(odf) + + tempogram = librosa.feature.tempogram(onset_envelope=odf, + sr=sr, + hop_length=hop_length, + win_length=len(odf), + window=np.ones, + center=center, + norm=None) + + idx = 0 + if center: + idx = len(odf)//2 + + assert np.allclose(odf_ac, tempogram[:, idx]) + + # Generate a synthetic onset envelope + def __test_peaks(tempo, win_length, window, norm): + # Generate an evenly-spaced pulse train + odf = np.zeros(duration * sr // hop_length) + spacing = sr * 60. // (hop_length * tempo) + odf[::int(spacing)] = 1 + + tempogram = librosa.feature.tempogram(onset_envelope=odf, + sr=sr, + hop_length=hop_length, + win_length=win_length, + window=window, + norm=norm) + + # Check the shape of the output + eq_(tempogram.shape[0], win_length) + + eq_(tempogram.shape[1], len(odf)) + + # Mean over time to wash over the boundary padding effects + idx = np.where(librosa.util.localmax(tempogram.max(axis=1)))[0] + + # Indices should all be non-zero integer multiples of spacing + assert np.allclose(idx, spacing * np.arange(1, 1 + len(idx))) + + for tempo in [60, 90, 120, 160, 200]: + for center in [False, True]: + yield __test_equiv, tempo, center + + for win_length in [192, 384]: + for window in [None, np.ones, np.ones(win_length)]: + for norm in [None, 1, 2, np.inf]: + yield __test_peaks, tempo, win_length, window, norm diff --git a/tests/test_filters.py b/tests/test_filters.py new file mode 100644 index 0000000000..ea0a1961a6 --- /dev/null +++ b/tests/test_filters.py @@ -0,0 +1,317 @@ +#!/usr/bin/env python +# CREATED:2013-03-08 15:25:18 by Brian McFee +# unit tests for librosa.feature (feature.py) +# +# Run me as follows: +# cd tests/ +# nosetests -v +# +# This test suite verifies that librosa core routines match (numerically) the output +# of various DPWE matlab implementations on a broad range of input parameters. +# +# All test data is generated by the Matlab script "makeTestData.m". +# Each test loads in a .mat file which contains the input and desired output for a given +# function. The test then runs the librosa implementation and verifies the results +# against the desired output, typically via numpy.allclose(). +# +# CAVEATS: +# +# Currently, not all tests are exhaustive in parameter space. This is typically due +# restricted functionality of the librosa implementations. Similarly, there is no +# fuzz-testing here, so behavior on invalid inputs is not yet well-defined. +# + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +import matplotlib +matplotlib.use('Agg') +import six +import glob +import numpy as np +import scipy.io + +from nose.tools import eq_, raises +import warnings + +import librosa + +# -- utilities --# +def files(pattern): + test_files = glob.glob(pattern) + test_files.sort() + return test_files + +def load(infile): + DATA = scipy.io.loadmat(infile, chars_as_strings=True) + return DATA +# -- --# + + +# -- Tests --# +def test_hz_to_mel(): + def __test_to_mel(infile): + DATA = load(infile) + z = librosa.hz_to_mel(DATA['f'], DATA['htk']) + + assert np.allclose(z, DATA['result']) + + for infile in files('data/feature-hz_to_mel-*.mat'): + yield (__test_to_mel, infile) + + pass + + +def test_mel_to_hz(): + + def __test_to_hz(infile): + DATA = load(infile) + z = librosa.mel_to_hz(DATA['f'], DATA['htk']) + + assert np.allclose(z, DATA['result']) + + for infile in files('data/feature-mel_to_hz-*.mat'): + yield (__test_to_hz, infile) + + pass + + +def test_hz_to_octs(): + def __test_to_octs(infile): + DATA = load(infile) + z = librosa.hz_to_octs(DATA['f']) + + assert np.allclose(z, DATA['result']) + + for infile in files('data/feature-hz_to_octs-*.mat'): + yield (__test_to_octs, infile) + + pass + + +def test_melfb(): + + def __test(infile): + DATA = load(infile) + + wts = librosa.filters.mel(DATA['sr'][0], + DATA['nfft'][0], + n_mels=DATA['nfilts'][0], + fmin=DATA['fmin'][0], + fmax=DATA['fmax'][0], + htk=DATA['htk'][0]) + + # Our version only returns the real-valued part. + # Pad out. + wts = np.pad(wts, [(0, 0), + (0, int(DATA['nfft'][0]//2 - 1))], + mode='constant') + + eq_(wts.shape, DATA['wts'].shape) + assert np.allclose(wts, DATA['wts']) + + for infile in files('data/feature-melfb-*.mat'): + yield (__test, infile) + + +def test_chromafb(): + + def __test(infile): + DATA = load(infile) + + octwidth = DATA['octwidth'][0, 0] + if octwidth == 0: + octwidth = None + + wts = librosa.filters.chroma(DATA['sr'][0, 0], + DATA['nfft'][0, 0], + DATA['nchroma'][0, 0], + A440=DATA['a440'][0, 0], + ctroct=DATA['ctroct'][0, 0], + octwidth=octwidth, + norm=2, + base_c=False) + + # Our version only returns the real-valued part. + # Pad out. + wts = np.pad(wts, [(0, 0), + (0, int(DATA['nfft'][0, 0]//2 - 1))], + mode='constant') + + eq_(wts.shape, DATA['wts'].shape) + assert np.allclose(wts, DATA['wts']) + + for infile in files('data/feature-chromafb-*.mat'): + yield (__test, infile) + + +def test__window(): + + def __test(n, window): + + wdec = librosa.filters.__float_window(window) + + if n == int(n): + n = int(n) + assert np.allclose(wdec(n), window(n)) + else: + wf = wdec(n) + fn = int(np.floor(n)) + assert not np.any(wf[fn:]) + + for n in [16, 16.0, 16.25, 16.75]: + for window_name in ['barthann', 'bartlett', 'blackman', + 'blackmanharris', 'bohman', 'boxcar', 'cosine', + 'flattop', 'hamming', 'hann', 'hanning', + 'nuttall', 'parzen', 'triang']: + window = getattr(scipy.signal.windows, window_name) + yield __test, n, window + + +def test_constant_q(): + + def __test(sr, fmin, n_bins, bins_per_octave, tuning, filter_scale, + pad_fft, norm): + + F, lengths = librosa.filters.constant_q(sr, + fmin=fmin, + n_bins=n_bins, + bins_per_octave=bins_per_octave, + tuning=tuning, + filter_scale=filter_scale, + pad_fft=pad_fft, + norm=norm) + + assert np.all(lengths <= F.shape[1]) + + eq_(len(F), n_bins) + + if not pad_fft: + return + + eq_(np.mod(np.log2(F.shape[1]), 1.0), 0.0) + + # Check for vanishing negative frequencies + F_fft = np.abs(np.fft.fft(F, axis=1)) + # Normalize by row-wise peak + F_fft = F_fft / np.max(F_fft, axis=1, keepdims=True) + assert not np.any(F_fft[:, -F_fft.shape[1]//2:] > 1e-4) + + sr = 11025 + + # Try to make a cq basis too close to nyquist + yield (raises(librosa.ParameterError)(__test), sr, sr/2.0, 1, 12, 0, 1, True, 1) + + # with negative fmin + yield (raises(librosa.ParameterError)(__test), sr, -60, 1, 12, 0, 1, True, 1) + + # with negative bins_per_octave + yield (raises(librosa.ParameterError)(__test), sr, 60, 1, -12, 0, 1, True, 1) + + # with negative bins + yield (raises(librosa.ParameterError)(__test), sr, 60, -1, 12, 0, 1, True, 1) + + # with negative filter_scale + yield (raises(librosa.ParameterError)(__test), sr, 60, 1, 12, 0, -1, True, 1) + + # with negative norm + yield (raises(librosa.ParameterError)(__test), sr, 60, 1, 12, 0, 1, True, -1) + + for fmin in [None, librosa.note_to_hz('C3')]: + for n_bins in [12, 24]: + for bins_per_octave in [12, 24]: + for tuning in [0, 0.25]: + for filter_scale in [1, 2]: + for norm in [1, 2]: + for pad_fft in [False, True]: + yield (__test, sr, fmin, n_bins, + bins_per_octave, tuning, + filter_scale, pad_fft, + norm) + + +def test_window_bandwidth(): + + eq_(librosa.filters.window_bandwidth('hann'), + librosa.filters.window_bandwidth(scipy.signal.hann)) + + +def test_window_bandwidth_missing(): + warnings.resetwarnings() + with warnings.catch_warnings(record=True) as out: + x = librosa.filters.window_bandwidth('unknown_window') + eq_(x, 1) + assert len(out) > 0 + assert out[0].category is UserWarning + assert 'Unknown window function' in str(out[0].message) + + +def binstr(m): + + out = [] + for row in m: + line = [' '] * len(row) + for i in np.flatnonzero(row): + line[i] = '.' + out.append(''.join(line)) + return '\n'.join(out) + + +def test_cq_to_chroma(): + + def __test(n_bins, bins_per_octave, n_chroma, fmin, base_c, window): + # Fake up a cqt matrix with the corresponding midi notes + + if fmin is None: + midi_base = 24 # C2 + else: + midi_base = librosa.hz_to_midi(fmin) + + midi_notes = np.linspace(midi_base, + midi_base + n_bins * 12.0 / bins_per_octave, + endpoint=False, + num=n_bins) + # We don't care past 2 decimals here. + # the log2 inside hz_to_midi can cause problems though. + midi_notes = np.around(midi_notes, decimals=2) + C = np.diag(midi_notes) + + cq2chr = librosa.filters.cq_to_chroma(n_input=C.shape[0], + bins_per_octave=bins_per_octave, + n_chroma=n_chroma, + fmin=fmin, + base_c=base_c, + window=window) + + chroma = cq2chr.dot(C) + for i in range(n_chroma): + v = chroma[i][chroma[i] != 0] + v = np.around(v, decimals=2) + + if base_c: + resid = np.mod(v, 12) + else: + resid = np.mod(v - 9, 12) + + resid = np.round(resid * n_chroma / 12.0) + assert np.allclose(np.mod(i - resid, 12), 0.0), i-resid + + for n_octaves in [2, 3, 4]: + for semitones in [1, 3]: + for n_chroma in 12 * np.arange(1, 1 + semitones): + for fmin in [None] + list(librosa.midi_to_hz(range(48, 61))): + for base_c in [False, True]: + for window in [None, [1]]: + bins_per_octave = 12 * semitones + n_bins = n_octaves * bins_per_octave + + if np.mod(bins_per_octave, n_chroma) != 0: + tf = raises(librosa.ParameterError)(__test) + else: + tf = __test + yield (tf, n_bins, bins_per_octave, + n_chroma, fmin, base_c, window) diff --git a/tests/test_met_features.py b/tests/test_met_features.py new file mode 100644 index 0000000000..732fd6ef5c --- /dev/null +++ b/tests/test_met_features.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +# CREATED:2015-02-16 13:10:05 by Brian McFee +'''Regression tests on metlab features''' + +from __future__ import print_function +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +import scipy.io +import scipy.signal + +from nose.tools import nottest, eq_, raises + +from test_core import load, files + +import librosa + +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +def met_stft(y, n_fft, hop_length, win_length, normalize): + + S = np.abs(librosa.stft(y, + n_fft=n_fft, + hop_length=hop_length, + win_length=win_length, + window=scipy.signal.hamming, + center=False)) + + if normalize: + S = S / (S[0] + np.sum(2 * S[1:], axis=0)) + + return S + + +def test_spectral_centroid(): + + def __test(infile): + DATA = load(infile) + + y, sr = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + n_fft = DATA['nfft'][0, 0].astype(int) + hop_length = DATA['hop_length'][0, 0].astype(int) + + # spectralCentroid uses normalized spectra + S = met_stft(y, n_fft, hop_length, n_fft, True) + + centroid = librosa.feature.spectral_centroid(S=S, + sr=sr, + n_fft=n_fft, + hop_length=hop_length) + + assert np.allclose(centroid, DATA['centroid']) + + for infile in files('data/met-centroid-*.mat'): + yield __test, infile + + +def test_spectral_contrast(): + + def __test(infile): + DATA = load(infile) + + y, sr = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + n_fft = DATA['nfft'][0, 0].astype(int) + hop_length = DATA['hop_length'][0, 0].astype(int) + + # spectralContrast uses normalized spectra + S = met_stft(y, n_fft, hop_length, n_fft, True) + + contrast = librosa.feature.spectral_contrast(S=S, sr=sr, + n_fft=n_fft, + hop_length=hop_length, + linear=True) + + assert np.allclose(contrast, DATA['contrast'], rtol=1e-3, atol=1e-2) + + for infile in files('data/met-contrast-*.mat'): + yield __test, infile + + +def test_spectral_rolloff(): + + def __test(infile): + DATA = load(infile) + + y, sr = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + n_fft = DATA['nfft'][0, 0].astype(int) + hop_length = DATA['hop_length'][0, 0].astype(int) + pct = DATA['pct'][0, 0] + + # spectralRolloff uses normalized spectra + S = met_stft(y, n_fft, hop_length, n_fft, True) + + rolloff = librosa.feature.spectral_rolloff(S=S, sr=sr, + n_fft=n_fft, + hop_length=hop_length, + roll_percent=pct) + + assert np.allclose(rolloff, DATA['rolloff']) + + for infile in files('data/met-rolloff-*.mat'): + yield __test, infile + + +def test_spectral_bandwidth(): + + def __test(infile): + DATA = load(infile) + + y, sr = librosa.load(DATA['wavfile'][0], sr=None, mono=True) + + n_fft = DATA['nfft'][0, 0].astype(int) + hop_length = DATA['hop_length'][0, 0].astype(int) + + S = DATA['S'] + + # normalization is disabled here, since the precomputed S is already + # normalized + # metlab uses p=1, other folks use p=2 + bw = librosa.feature.spectral_bandwidth(S=S, sr=sr, + n_fft=n_fft, + hop_length=hop_length, + centroid=DATA['centroid'], + norm=False, + p=1) + + # METlab implementation takes the mean, not the sum + assert np.allclose(bw, S.shape[0] * DATA['bw']) + + for infile in files('data/met-bandwidth-*.mat'): + yield __test, infile diff --git a/tests/test_onset.py b/tests/test_onset.py new file mode 100644 index 0000000000..2ccbed5ec6 --- /dev/null +++ b/tests/test_onset.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python +# CREATED:2013-03-11 18:14:30 by Brian McFee +# unit tests for librosa.beat + +from __future__ import print_function +from nose.tools import raises, eq_ + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') + +import warnings + +import numpy as np +import librosa + +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +def test_onset_strength_audio(): + + def __test(y, sr, feature, n_fft, hop_length, lag, max_size, detrend, center, aggregate): + + oenv = librosa.onset.onset_strength(y=y, sr=sr, + S=None, + detrend=detrend, + center=center, + aggregate=aggregate, + feature=feature, + n_fft=n_fft, + hop_length=hop_length, + lag=lag, + max_size=max_size) + + assert oenv.ndim == 1 + + S = librosa.feature.melspectrogram(y=y, + n_fft=n_fft, + hop_length=hop_length) + + target_shape = S.shape[-1] + + #if center: + # target_shape += n_fft // (2 * hop_length) + + if not detrend: + assert np.all(oenv >= 0) + + eq_(oenv.shape[-1], target_shape) + + y, sr = librosa.load(__EXAMPLE_FILE) + + for feature in [None, + librosa.feature.melspectrogram, + librosa.feature.chroma_stft]: + for n_fft in [512, 2048]: + for hop_length in [n_fft // 2, n_fft // 4]: + for lag in [0, 1, 2]: + for max_size in [0, 1, 2]: + for detrend in [False, True]: + for center in [False, True]: + for aggregate in [None, np.mean, np.max]: + if lag < 1 or max_size < 1: + tf = raises(librosa.ParameterError)(__test) + else: + tf = __test + + yield (tf, y, sr, feature, n_fft, + hop_length, lag, max_size, detrend, center, aggregate) + + tf = raises(librosa.ParameterError)(__test) + yield (tf, None, sr, feature, n_fft, + hop_length, lag, max_size, detrend, center, aggregate) + + +def test_onset_strength_spectrogram(): + + def __test(S, sr, feature, n_fft, hop_length, detrend, center): + + oenv = librosa.onset.onset_strength(y=None, sr=sr, + S=S, + detrend=detrend, + center=center, + aggregate=aggregate, + feature=feature, + n_fft=n_fft, + hop_length=hop_length) + + assert oenv.ndim == 1 + + target_shape = S.shape[-1] + + #if center: + # target_shape += n_fft // (2 * hop_length) + + if not detrend: + assert np.all(oenv >= 0) + + eq_(oenv.shape[-1], target_shape) + + y, sr = librosa.load(__EXAMPLE_FILE) + S = librosa.feature.melspectrogram(y=y, sr=sr) + + for feature in [None, + librosa.feature.melspectrogram, + librosa.feature.chroma_stft]: + for n_fft in [512, 2048]: + for hop_length in [n_fft // 2, n_fft // 4]: + for detrend in [False, True]: + for center in [False, True]: + for aggregate in [None, np.mean, np.max]: + yield (__test, S, sr, feature, n_fft, + hop_length, detrend, center) + tf = raises(librosa.ParameterError)(__test) + yield (tf, None, sr, feature, n_fft, + hop_length, detrend, center) + + +def test_onset_strength_multi(): + + y, sr = librosa.load(__EXAMPLE_FILE) + S = librosa.feature.melspectrogram(y=y, sr=sr) + + channels = np.linspace(0, S.shape[0], num=5).astype(int) + + for lag in [1, 2, 3]: + for max_size in [1]: + # We only test with max_size=1 here to make the sub-band slicing test simple + odf_multi = librosa.onset.onset_strength_multi(S=S, + lag=lag, max_size=1, + channels=channels) + + eq_(len(odf_multi), len(channels) - 1) + + for i, (s, t) in enumerate(zip(channels, channels[1:])): + odf_single = librosa.onset.onset_strength(S=S[s:t], + lag=lag, + max_size=1) + assert np.allclose(odf_single, odf_multi[i]) + + +def test_onset_detect_real(): + + def __test(y, sr, oenv, hop_length): + + onsets = librosa.onset.onset_detect(y=y, sr=sr, onset_envelope=oenv, + hop_length=hop_length) + + assert np.all(onsets > 0) + assert np.all(onsets < len(y) * sr // hop_length) + if oenv is not None: + assert np.all(onsets < len(oenv)) + + y, sr = librosa.load(__EXAMPLE_FILE) + + # Test with no signal + yield raises(librosa.ParameterError)(__test), None, sr, None, 512 + + for hop_length in [64, 512, 2048]: + yield __test, y, sr, None, hop_length + oenv = librosa.onset.onset_strength(y=y, sr=sr, hop_length=hop_length) + yield __test, y, sr, oenv, hop_length + + +def test_onset_detect_const(): + + def __test(y, sr, oenv, hop_length): + + onsets = librosa.onset.onset_detect(y=y, sr=sr, onset_envelope=oenv, + hop_length=hop_length) + + eq_(len(onsets), 0) + + sr = 22050 + duration = 3.0 + for f in [np.zeros, np.ones]: + y = f(int(duration * sr)) + for hop_length in [64, 512, 2048]: + yield __test, y, sr, None, hop_length + yield __test, -y, sr, None, hop_length + oenv = librosa.onset.onset_strength(y=y, + sr=sr, + hop_length=hop_length) + yield __test, y, sr, oenv, hop_length + + +def test_onset_strength_deprecated(): + + y, sr = librosa.load(__EXAMPLE_FILE) + + def __test(centering): + + no_warning = (centering is None) + + warnings.resetwarnings() + warnings.simplefilter('always') + with warnings.catch_warnings(record=True) as out: + librosa.onset.onset_strength(y=y, sr=sr, centering=centering) + + if no_warning: + eq_(out, []) + else: + assert len(out) > 0 + assert out[0].category is DeprecationWarning + assert 'deprecated' in str(out[0].message).lower() + + + for centering in [True, False, None]: + yield __test, centering diff --git a/tests/test_output.py b/tests/test_output.py new file mode 100644 index 0000000000..5a02108016 --- /dev/null +++ b/tests/test_output.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +'''Tests for output functions''' + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import librosa +import numpy as np +import tempfile +from nose.tools import raises, eq_ + + +def test_write_wav(): + + def __test(mono, norm): + + y, sr = librosa.load('data/test1_22050.wav', sr=None, mono=mono) + + _, tfname = tempfile.mkstemp() + + librosa.output.write_wav(tfname, y, sr, norm=norm) + + y_2, sr2 = librosa.load(tfname, sr=None, mono=mono) + + os.unlink(tfname) + + librosa.util.valid_audio(y_2, mono=mono) + + assert np.allclose(sr2, sr) + + if norm: + assert np.allclose(librosa.util.normalize(y, axis=-1), + librosa.util.normalize(y_2, axis=-1), + rtol=1e-3, atol=1e-4) + else: + assert np.allclose(y, y_2, rtol=1e-3, atol=1e-4) + + for mono in [False, True]: + for norm in [False, True]: + yield __test, mono, norm + + +def test_times_csv(): + + def __test(times, annotations, sep): + + _, tfname = tempfile.mkstemp() + + # Dump to disk + librosa.output.times_csv(tfname, times, annotations=annotations, + delimiter=sep) + + # Load it back + with open(tfname, 'r') as fdesc: + lines = [line for line in fdesc] + + # Remove the file + os.unlink(tfname) + + for i, line in enumerate(lines): + if annotations is None: + t_in = line.strip() + else: + t_in, ann_in = line.strip().split(sep, 2) + t_in = float(t_in) + + assert np.allclose(times[i], t_in, atol=1e-3, rtol=1e-3) + if annotations is not None: + eq_(str(annotations[i]), ann_in) + + __test_fail = raises(librosa.ParameterError)(__test) + + for times in [[], np.linspace(0, 10, 20)]: + for annotations in [None, ['abcde'[q] for q in np.random.randint(0, 5, + size=len(times))], list('abcde')]: + for sep in [',', '\t', ' ']: + + if annotations is not None and len(annotations) != len(times): + yield __test_fail, times, annotations, sep + else: + yield __test, times, annotations, sep + + +def test_frames_csv(): + + def __test(frames, sr, hop, n_fft, annotations, sep): + + _, tfname = tempfile.mkstemp() + + # Dump to disk + librosa.output.frames_csv(tfname, frames, sr=sr, hop_length=hop, + n_fft=n_fft, + annotations=annotations, + delimiter=sep) + + times = librosa.core.frames_to_time(frames, sr=sr, hop_length=hop, + n_fft=n_fft) + # Load it back + with open(tfname, 'r') as fdesc: + lines = [line for line in fdesc] + + # Remove the file + os.unlink(tfname) + + for i, line in enumerate(lines): + if annotations is None: + t_in = line.strip() + else: + t_in, ann_in = line.strip().split(sep, 2) + + t_in = float(t_in) + if annotations is not None: + annotations[i], ann_in + eq_(str(annotations[i]), ann_in) + assert np.allclose(times[i], t_in, atol=1e-3, rtol=1e-3) + + __test_fail = raises(librosa.ParameterError)(__test) + + for frames in [np.asarray([]), np.arange(0, 22050 * 3, 1000)]: + for annotations in [None, ['abcde'[q] for q in np.random.randint(0, 5, + size=len(frames))], list('abcde')]: + for sep in [',', '\t', ' ']: + for n_fft in [None, 1024, 2048]: + for hop_length in [64, 512]: + for sr in [22050, 11025]: + my_test = __test + if (annotations is not None + and len(annotations) != len(frames)): + my_test = __test_fail + + yield (my_test, frames, sr, + hop_length, n_fft, annotations, sep) + + +def test_annotation(): + + def __test(times, annotations, sep): + + _, tfname = tempfile.mkstemp() + + # Dump to disk + librosa.output.annotation(tfname, times, annotations=annotations, + delimiter=sep) + + # Load it back + with open(tfname, 'r') as fdesc: + lines = [line for line in fdesc] + + # Remove the file + os.unlink(tfname) + + for i, line in enumerate(lines): + if annotations is None: + t_in1, t_in2 = line.strip().split(sep, 2) + else: + t_in1, t_in2, ann_in = line.strip().split(sep, 3) + t_in1 = float(t_in1) + t_in2 = float(t_in2) + + assert np.allclose(times[i], [t_in1, t_in2], + atol=1e-3, rtol=1e-3) + + if annotations is not None: + eq_(str(annotations[i]), ann_in) + + __test_fail = raises(librosa.ParameterError)(__test) + + times = np.random.randn(20, 2) + + for annotations in [None, ['abcde'[q] for q in np.random.randint(0, 5, + size=len(times))], list('abcde')]: + for sep in [',', '\t', ' ']: + if annotations is not None and len(annotations) != len(times): + yield __test_fail, times, annotations, sep + else: + yield __test, times, annotations, sep diff --git a/tests/test_segment.py b/tests/test_segment.py new file mode 100644 index 0000000000..70e052afbc --- /dev/null +++ b/tests/test_segment.py @@ -0,0 +1,249 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +'''Tests for segmentation functions''' + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +from nose.tools import raises + +import librosa +__EXAMPLE_FILE = 'data/test1_22050.wav' + + +def test_band_infinite(): + + def __test(width, n, v_in, v_out): + B = librosa.segment.__band_infinite(n, width, v_in=v_in, v_out=v_out) + + idx = np.tril_indices(n, k=width-1) + + # First check the shape + assert np.allclose(B.shape, [n, n]) + + # Check symmetry + assert np.allclose(B, B.T) + + # Check in-band first + Bincheck = B.copy() + Bincheck[idx] = v_in + Bincheck.T[idx] = v_in + + assert np.all(Bincheck == v_in) + + # If we're too small to have an out-of-band, then we're done + if not len(idx[0]): + return + + Boutcheck = B.copy() + Boutcheck[idx] = v_out + Boutcheck.T[idx] = v_out + + assert np.all(Boutcheck == v_out) + + @raises(librosa.ParameterError) + def __test_fail(width, n, v_in, v_out): + librosa.segment.__band_infinite(n, width, v_in=v_in, v_out=v_out) + + for width in [0, 1, 2, 3, 5, 9]: + for n in [width//2, width, width+1, width * 2, width**2]: + if width > n: + yield __test_fail, width, n, -1, +1 + else: + yield __test, width, n, -1, +1 + + +def test_recurrence_matrix(): + + def __test(n, k, width, sym): + # Make a data matrix + data = np.random.randn(3, n) + + D = librosa.segment.recurrence_matrix(data, k=k, width=width, sym=sym, axis=-1) + + + # First test for symmetry + if sym: + assert np.allclose(D, D.T) + + # Test for target-axis invariance + D_trans = librosa.segment.recurrence_matrix(data.T, k=k, width=width, sym=sym, axis=0) + assert np.allclose(D, D_trans) + + # If not symmetric, test for correct number of links + if not sym and k is not None: + real_k = min(k, n - width) + assert not np.any(D.sum(axis=1) != real_k) + + # Make sure the +- width diagonal is hollow + # It's easier to test if zeroing out the triangles leaves nothing + idx = np.tril_indices(n, k=width) + + D[idx] = False + D.T[idx] = False + assert not np.any(D) + + + for n in [10, 100, 1000]: + for k in [None, int(n/4)]: + for sym in [False, True]: + for width in [-1, 0, 1, 3, 5]: + tester = __test + if width < 1: + tester = raises(librosa.ParameterError)(__test) + + yield tester, n, k, width, sym + + +def test_recurrence_to_lag(): + + def __test(n, pad): + data = np.random.randn(17, n) + + rec = librosa.segment.recurrence_matrix(data) + + lag = librosa.segment.recurrence_to_lag(rec, pad=pad, axis=-1) + lag2 = librosa.segment.recurrence_to_lag(rec.T, pad=pad, axis=0).T + + assert np.allclose(lag, lag2) + + x = Ellipsis + if pad: + x = slice(n) + + for i in range(n): + assert np.allclose(rec[:, i], np.roll(lag[:, i], i)[x]) + + @raises(librosa.ParameterError) + def __test_fail(size): + librosa.segment.recurrence_to_lag(np.zeros(size)) + + for n in [10, 100, 1000]: + for pad in [False, True]: + yield __test, n, pad + + yield __test_fail, (17,) + yield __test_fail, (17, 34) + yield __test_fail, (17, 17, 17) + + +def test_lag_to_recurrence(): + + def __test(n, pad): + data = np.random.randn(17, n) + + rec = librosa.segment.recurrence_matrix(data) + lag = librosa.segment.recurrence_to_lag(rec, pad=pad, axis=-1) + lag2 = librosa.segment.recurrence_to_lag(rec.T, pad=pad, axis=0).T + + rec2 = librosa.segment.lag_to_recurrence(lag) + + assert np.allclose(rec, rec2) + assert np.allclose(lag, lag2) + + @raises(librosa.ParameterError) + def __test_fail(size): + librosa.segment.lag_to_recurrence(np.zeros(size)) + + for n in [10, 100, 1000]: + for pad in [False, True]: + yield __test, n, pad + + yield __test_fail, (17,) + yield __test_fail, (17, 35) + yield __test_fail, (17, 17, 17) + + +def test_structure_feature(): + + def __test(n, pad): + # Make a data matrix + data = np.random.randn(17, n) + + # Make a recurrence plot + rec = librosa.segment.recurrence_matrix(data) + + # Make a structure feature + st = librosa.segment.structure_feature(rec, pad=pad, inverse=False) + + # Test for each column + if pad: + x = slice(n) + else: + x = Ellipsis + + for i in range(n): + assert np.allclose(rec[:, i], np.roll(st[:, i], i)[x]) + + # Invert it + rec2 = librosa.segment.structure_feature(st, pad=pad, inverse=True) + + assert np.allclose(rec, rec2) + + for n in [10, 100, 1000]: + for pad in [False, True]: + yield __test, n, pad + + +def test_timelag_filter(): + + def pos0_filter(X): + return X + + def pos1_filter(_, X): + return X + + def __test_positional(n): + dpos0 = librosa.segment.timelag_filter(pos0_filter) + dpos1 = librosa.segment.timelag_filter(pos1_filter, index=1) + + X = np.random.randn(n, n) + + assert np.allclose(X, dpos0(X)) + assert np.allclose(X, dpos1(None, X)) + + yield __test_positional, 25 + + +def test_subsegment(): + + y, sr = librosa.load(__EXAMPLE_FILE) + + X = librosa.feature.mfcc(y=y, sr=sr, hop_length=512) + tempo, beats = librosa.beat.beat_track(y=y, sr=sr, hop_length=512) + + def __test(n_segments): + + subseg = librosa.segment.subsegment(X, beats, n_segments=n_segments, axis=-1) + + # Make sure that the boundaries are within range + assert subseg.min() >= 0 + assert subseg.max() <= X.shape[-1] + + # Make sure that all input beats are retained + for b in beats: + assert b in subseg + + # Do we have a 0 marker? + assert 0 in subseg + + # Did we over-segment? +2 here for 0- and end-padding + assert len(subseg) <= n_segments * (len(beats) + 2) + + # Verify that running on the transpose gives the same answer + ss2 = librosa.segment.subsegment(X.T, beats, n_segments=n_segments, axis=0) + assert np.allclose(subseg, ss2) + + for n_segments in [0, 1, 2, 3, 4, 100]: + if n_segments < 1: + tf = raises(librosa.ParameterError, IndexError)(__test) + else: + tf = __test + yield tf, n_segments diff --git a/tests/test_time_frequency.py b/tests/test_time_frequency.py new file mode 100644 index 0000000000..e42865cefe --- /dev/null +++ b/tests/test_time_frequency.py @@ -0,0 +1,339 @@ +#!/usr/bin/env python +# -*- encoding: utf-8 -*- +# CREATED:2015-02-14 19:13:49 by Brian McFee +'''Unit tests for time and frequency conversion''' + +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except KeyError: + pass + +import matplotlib +matplotlib.use('Agg') + +import librosa +import numpy as np +from nose.tools import raises, eq_ + + +def test_frames_to_samples(): + + def __test(x, y, hop_length, n_fft): + y_test = librosa.frames_to_samples(x, + hop_length=hop_length, + n_fft=n_fft) + assert np.allclose(y, y_test) + + x = np.arange(2) + for hop_length in [512, 1024]: + for n_fft in [None, 1024]: + y = x * hop_length + if n_fft is not None: + y += n_fft // 2 + yield __test, x, y, hop_length, n_fft + + +def test_samples_to_frames(): + + def __test(x, y, hop_length, n_fft): + y_test = librosa.samples_to_frames(x, + hop_length=hop_length, + n_fft=n_fft) + assert np.allclose(y, y_test) + + x = np.arange(2) + for hop_length in [512, 1024]: + for n_fft in [None, 1024]: + y = x * hop_length + if n_fft is not None: + y += n_fft // 2 + yield __test, y, x, hop_length, n_fft + + +def test_frames_to_time(): + + def __test(sr, hop_length, n_fft): + + # Generate frames at times 0s, 1s, 2s + frames = np.arange(3) * sr // hop_length + + if n_fft: + frames -= n_fft // (2 * hop_length) + + times = librosa.frames_to_time(frames, + sr=sr, + hop_length=hop_length, + n_fft=n_fft) + + # we need to be within one frame + assert np.all(np.abs(times - np.asarray([0, 1, 2])) * sr + < hop_length) + + for sr in [22050, 44100]: + for hop_length in [256, 512]: + for n_fft in [None, 2048]: + yield __test, sr, hop_length, n_fft + + +def test_time_to_samples(): + + def __test(sr): + assert np.allclose(librosa.time_to_samples([0, 1, 2], sr=sr), + [0, sr, 2 * sr]) + + for sr in [22050, 44100]: + yield __test, sr + + +def test_samples_to_time(): + + def __test(sr): + assert np.allclose(librosa.samples_to_time([0, sr, 2 * sr], sr=sr), + [0, 1, 2]) + + for sr in [22050, 44100]: + yield __test, sr + + +def test_time_to_frames(): + + def __test(sr, hop_length, n_fft): + + # Generate frames at times 0s, 1s, 2s + times = np.arange(3) + + frames = librosa.time_to_frames(times, + sr=sr, + hop_length=hop_length, + n_fft=n_fft) + + if n_fft: + frames -= n_fft // (2 * hop_length) + + # we need to be within one frame + assert np.all(np.abs(times - np.asarray([0, 1, 2])) * sr + < hop_length) + + for sr in [22050, 44100]: + for hop_length in [256, 512]: + for n_fft in [None, 2048]: + yield __test, sr, hop_length, n_fft + + +def test_octs_to_hz(): + def __test(a440): + freq = np.asarray([55, 110, 220, 440]) * (float(a440) / 440.0) + freq_out = librosa.octs_to_hz([1, 2, 3, 4], A440=a440) + + assert np.allclose(freq, freq_out) + + for a440 in [415, 430, 435, 440, 466]: + yield __test, a440 + + +def test_hz_to_octs(): + def __test(a440): + freq = np.asarray([55, 110, 220, 440]) * (float(a440) / 440.0) + octs = [1, 2, 3, 4] + oct_out = librosa.hz_to_octs(freq, A440=a440) + + assert np.allclose(octs, oct_out) + + for a440 in [415, 430, 435, 440, 466]: + yield __test, a440 + + +def test_note_to_midi(): + + def __test(tuning, accidental, octave, round_midi): + + note = 'C{:s}'.format(accidental) + + if octave is not None: + note = '{:s}{:d}'.format(note, octave) + else: + octave = 0 + + if tuning is not None: + note = '{:s}{:+d}'.format(note, tuning) + else: + tuning = 0 + + midi_true = 12 * (octave + 1) + tuning * 0.01 + + if accidental == '#': + midi_true += 1 + elif accidental in list('b!'): + midi_true -= 1 + + midi = librosa.note_to_midi(note, round_midi=round_midi) + if round_midi: + midi_true = np.round(midi_true) + eq_(midi, midi_true) + + midi = librosa.note_to_midi([note], round_midi=round_midi) + eq_(midi[0], midi_true) + + @raises(librosa.ParameterError) + def __test_fail(): + librosa.note_to_midi('does not pass') + + for tuning in [None, -25, 0, 25]: + for octave in [None, 1, 2, 3]: + if octave is None and tuning is not None: + continue + for accidental in ['', '#', 'b', '!']: + for round_midi in [False, True]: + yield __test, tuning, accidental, octave, round_midi + + yield __test_fail + + +def test_note_to_hz(): + + def __test(tuning, accidental, octave, round_midi): + + note = 'A{:s}'.format(accidental) + + if octave is not None: + note = '{:s}{:d}'.format(note, octave) + else: + octave = 0 + + if tuning is not None: + note = '{:s}{:+d}'.format(note, tuning) + else: + tuning = 0 + + if round_midi: + tuning = np.around(tuning, -2) + + hz_true = 440.0 * (2.0**(tuning * 0.01 / 12)) * (2.0**(octave - 4)) + + if accidental == '#': + hz_true *= 2.0**(1./12) + elif accidental in list('b!'): + hz_true /= 2.0**(1./12) + + hz = librosa.note_to_hz(note, round_midi=round_midi) + assert np.allclose(hz[0], hz_true) + + @raises(librosa.ParameterError) + def __test_fail(): + librosa.note_to_midi('does not pass') + + for tuning in [None, -25, 0, 25]: + for octave in [None, 1, 2, 3]: + if octave is None and tuning is not None: + continue + for accidental in ['', '#', 'b', '!']: + for round_midi in [False, True]: + yield __test, tuning, accidental, octave, round_midi + + yield __test_fail + + +def test_midi_to_note(): + + def __test(midi_num, note, octave, cents): + note_out = librosa.midi_to_note(midi_num, octave=octave, cents=cents) + + eq_(note_out, note) + + midi_num = 24.25 + + yield __test, midi_num, 'C', False, False + yield __test, midi_num, 'C1', True, False + yield raises(librosa.ParameterError)(__test), midi_num, 'C+25', False, True + yield __test, midi_num, 'C1+25', True, True + yield __test, [midi_num], ['C'], False, False + + +def test_midi_to_hz(): + + assert np.allclose(librosa.midi_to_hz([33, 45, 57, 69]), + [55, 110, 220, 440]) + + +def test_hz_to_midi(): + assert np.allclose(librosa.hz_to_midi([55, 110, 220, 440]), + [33, 45, 57, 69]) + + +def test_hz_to_note(): + def __test(hz, note, octave, cents): + note_out = librosa.hz_to_note(hz, octave=octave, cents=cents) + + eq_(list(note_out), list([note])) + + hz = 440 + + yield __test, hz, 'A', False, False + yield __test, hz, 'A4', True, False + yield raises(librosa.ParameterError)(__test), hz, 'A+0', False, True + yield __test, hz, 'A4+0', True, True + + +def test_fft_frequencies(): + + def __test(sr, n_fft): + freqs = librosa.fft_frequencies(sr=sr, n_fft=n_fft) + + # DC + eq_(freqs[0], 0) + + # Nyquist, positive here for more convenient display purposes + eq_(freqs[-1], sr / 2.0) + + # Ensure that the frequencies increase linearly + dels = np.diff(freqs) + assert np.allclose(dels, dels[0]) + + for n_fft in [1024, 2048]: + for sr in [8000, 22050]: + yield __test, sr, n_fft + + +def test_cqt_frequencies(): + + def __test(n_bins, fmin, bins_per_octave, tuning): + + freqs = librosa.cqt_frequencies(n_bins, + fmin, + bins_per_octave=bins_per_octave, + tuning=tuning) + + # Make sure we get the right number of bins + eq_(len(freqs), n_bins) + + # And that the first bin matches fmin by tuning + assert np.allclose(freqs[0], + fmin * 2.0**(float(tuning) / bins_per_octave)) + + # And that we have constant Q + Q = np.diff(np.log2(freqs)) + assert np.allclose(Q, 1./bins_per_octave) + + for n_bins in [12, 24, 36]: + for fmin in [440.0]: + for bins_per_octave in [12, 24, 36]: + for tuning in [-0.25, 0.0, 0.25]: + yield __test, n_bins, fmin, bins_per_octave, tuning + + +def test_A_weighting(): + + def __test(min_db): + # Check that 1KHz is around 0dB + a_khz = librosa.A_weighting(1000.0, min_db=min_db) + assert np.allclose(a_khz, 0, atol=1e-3) + + a_range = librosa.A_weighting(np.linspace(2e1, 2e4), + min_db=min_db) + # Check that the db cap works + if min_db is not None: + assert not np.any(a_range < min_db) + + for min_db in [None, -40, -80]: + yield __test, min_db diff --git a/tests/test_util.py b/tests/test_util.py new file mode 100644 index 0000000000..0ff1bd7bf9 --- /dev/null +++ b/tests/test_util.py @@ -0,0 +1,777 @@ +#!/usr/bin/env python +# CREATED:2014-01-18 14:09:05 by Brian McFee +# unit tests for util routines + +# Disable cache +import os +try: + os.environ.pop('LIBROSA_CACHE_DIR') +except: + pass + +import matplotlib +matplotlib.use('Agg') +import numpy as np +np.set_printoptions(precision=3) +from nose.tools import raises, eq_ +import six +import warnings + +import librosa + + +def test_example_audio_file(): + + assert os.path.exists(librosa.util.example_audio_file()) + + +def test_frame(): + + # Generate a random time series + def __test(P): + frame, hop = P + + y = np.random.randn(8000) + y_frame = librosa.util.frame(y, frame_length=frame, hop_length=hop) + + for i in range(y_frame.shape[1]): + assert np.allclose(y_frame[:, i], y[i * hop:(i * hop + frame)]) + + for frame in [256, 1024, 2048]: + for hop_length in [64, 256, 512]: + yield (__test, [frame, hop_length]) + + +def test_pad_center(): + + def __test(y, n, axis, mode): + + y_out = librosa.util.pad_center(y, n, axis=axis, mode=mode) + + n_len = y.shape[axis] + n_pad = int((n - n_len) / 2) + + eq_slice = [slice(None)] * y.ndim + eq_slice[axis] = slice(n_pad, n_pad + n_len) + + assert np.allclose(y, y_out[eq_slice]) + + @raises(librosa.ParameterError) + def __test_fail(y, n, axis, mode): + librosa.util.pad_center(y, n, axis=axis, mode=mode) + + for shape in [(16,), (16, 16)]: + y = np.ones(shape) + + for axis in [0, -1]: + for mode in ['constant', 'edge', 'reflect']: + for n in [0, 10]: + yield __test, y, n + y.shape[axis], axis, mode + + for n in [0, 10]: + yield __test_fail, y, n, axis, mode + + +def test_fix_length(): + + def __test(y, n, axis): + + y_out = librosa.util.fix_length(y, n, axis=axis) + + eq_slice = [slice(None)] * y.ndim + eq_slice[axis] = slice(y.shape[axis]) + + if n > y.shape[axis]: + assert np.allclose(y, y_out[eq_slice]) + else: + assert np.allclose(y[eq_slice], y) + + for shape in [(16,), (16, 16)]: + y = np.ones(shape) + + for axis in [0, -1]: + for n in [-5, 0, 5]: + yield __test, y, n + y.shape[axis], axis + + +def test_fix_frames(): + + @raises(librosa.ParameterError) + def __test_fail(frames, x_min, x_max, pad): + librosa.util.fix_frames(frames, x_min, x_max, pad) + + def __test_pass(frames, x_min, x_max, pad): + + f_fix = librosa.util.fix_frames(frames, + x_min=x_min, + x_max=x_max, + pad=pad) + + if x_min is not None: + if pad: + assert f_fix[0] == x_min + assert np.all(f_fix >= x_min) + + if x_max is not None: + if pad: + assert f_fix[-1] == x_max + assert np.all(f_fix <= x_max) + + for low in [-20, 0, 20]: + for high in [low + 20, low + 50, low + 100]: + + frames = np.random.randint(low, high=high, size=15) + + for x_min in [None, 0, 20]: + for x_max in [None, 20, 100]: + for pad in [False, True]: + if np.any(frames < 0): + yield __test_fail, frames, x_min, x_max, pad + else: + yield __test_pass, frames, x_min, x_max, pad + + +def test_normalize(): + + def __test_pass(X, norm, axis): + X_norm = librosa.util.normalize(X, norm=norm, axis=axis) + + if norm is None: + assert np.allclose(X, X_norm) + return + + X_norm = np.abs(X_norm) + + if norm == np.inf: + values = np.max(X_norm, axis=axis) + elif norm == -np.inf: + values = np.min(X_norm, axis=axis) + elif norm == 0: + # XXX: normalization here isn't quite right + values = np.ones(1) + + else: + values = np.sum(X_norm**norm, axis=axis)**(1./norm) + + assert np.allclose(values, np.ones_like(values)) + + @raises(librosa.ParameterError) + def __test_fail(X, norm, axis): + librosa.util.normalize(X, norm=norm, axis=axis) + + for ndims in [1, 2, 3]: + X = np.random.randn(* ([16] * ndims)) + + for axis in range(X.ndim): + for norm in [np.inf, -np.inf, 0, 0.5, 1.0, 2.0, None]: + yield __test_pass, X, norm, axis + + for norm in ['inf', -0.5, -2]: + yield __test_fail, X, norm, axis + + +def test_axis_sort(): + + def __test_pass(data, axis, index, value): + + if index: + Xsorted, idx = librosa.util.axis_sort(data, + axis=axis, + index=index, + value=value) + + cmp_slice = [slice(None)] * X.ndim + cmp_slice[axis] = idx + + assert np.allclose(X[cmp_slice], Xsorted) + + else: + Xsorted = librosa.util.axis_sort(data, + axis=axis, + index=index, + value=value) + + compare_axis = np.mod(1 - axis, 2) + + if value is None: + value = np.argmax + + sort_values = value(Xsorted, axis=compare_axis) + + assert np.allclose(sort_values, np.sort(sort_values)) + + @raises(librosa.ParameterError) + def __test_fail(data, axis, index, value): + librosa.util.axis_sort(data, axis=axis, index=index, value=value) + + for ndim in [1, 2, 3]: + X = np.random.randn(*([10] * ndim)) + + for axis in [0, 1, -1]: + for index in [False, True]: + for value in [None, np.min, np.mean, np.max]: + + if ndim == 2: + yield __test_pass, X, axis, index, value + else: + yield __test_fail, X, axis, index, value + + +def test_match_intervals(): + + def __make_intervals(n): + return np.cumsum(np.abs(np.random.randn(n, 2)), axis=1) + + def __compare(i1, i2): + + return np.maximum(0, np.minimum(i1[-1], i2[-1]) + - np.maximum(i1[0], i2[0])) + + def __is_best(y, ints1, ints2): + + for i in range(len(y)): + values = np.asarray([__compare(ints1[i], i2) for i2 in ints2]) + if np.any(values > values[y[i]]): + return False + + return True + + def __test(n, m): + ints1 = __make_intervals(n) + ints2 = __make_intervals(m) + + y_pred = librosa.util.match_intervals(ints1, ints2) + + assert __is_best(y_pred, ints1, ints2) + + @raises(librosa.ParameterError) + def __test_fail(n, m): + ints1 = __make_intervals(n) + ints2 = __make_intervals(m) + + librosa.util.match_intervals(ints1, ints2) + + for n in [0, 1, 5, 20, 100]: + for m in [0, 1, 5, 20, 100]: + if n == 0 or m == 0: + yield __test_fail, n, m + else: + yield __test, n, m + + # TODO: 2015-01-20 17:04:55 by Brian McFee + # add coverage for shape errors + + +def test_match_events(): + + def __make_events(n): + return np.abs(np.random.randn(n)) + + def __is_best(y, ev1, ev2): + for i in range(len(y)): + values = np.asarray([np.abs(ev1[i] - e2) for e2 in ev2]) + if np.any(values < values[y[i]]): + return False + + return True + + def __test(n, m): + ev1 = __make_events(n) + ev2 = __make_events(m) + + y_pred = librosa.util.match_events(ev1, ev2) + + assert __is_best(y_pred, ev1, ev2) + + @raises(librosa.ParameterError) + def __test_fail(n, m): + ev1 = __make_events(n) + ev2 = __make_events(m) + librosa.util.match_events(ev1, ev2) + + for n in [0, 1, 5, 20, 100]: + for m in [0, 1, 5, 20, 100]: + if n == 0 or m == 0: + yield __test_fail, n, m + else: + yield __test, n, m + + +def test_localmax(): + + def __test(ndim, axis): + + data = np.random.randn(*([20] * ndim)) + + lm = librosa.util.localmax(data, axis=axis) + + for hits in np.argwhere(lm): + for offset in [-1, 1]: + compare_idx = hits.copy() + compare_idx[axis] += offset + + if compare_idx[axis] < 0: + continue + + if compare_idx[axis] >= data.shape[axis]: + continue + + if offset < 0: + assert data[tuple(hits)] > data[tuple(compare_idx)] + else: + assert data[tuple(hits)] >= data[tuple(compare_idx)] + + for ndim in range(1, 5): + for axis in range(ndim): + yield __test, ndim, axis + + +def test_feature_extractor(): + + y, sr = librosa.load('data/test1_22050.wav') + + def __test_positional_iterate(myfunc, args): + + output_raw = myfunc(y, **args) + + FP = librosa.util.FeatureExtractor(myfunc, **args) + output = FP.transform([y]) + + assert np.allclose(output, output_raw) + + # Ensure that fitting does nothing + FP.fit() + output = FP.transform([y]) + assert np.allclose(output, output_raw) + + def __test_positional(myfunc, args): + + output_raw = myfunc(y, **args) + + FP = librosa.util.FeatureExtractor(myfunc, iterate=False, **args) + output = FP.transform(y) + + assert np.allclose(output, output_raw) + + # Ensure that fitting does nothing + FP.fit() + output = FP.transform(y) + assert np.allclose(output, output_raw) + + def __test_keyword_iterate(myfunc, args): + + output_raw = myfunc(y=y, **args) + + FP = librosa.util.FeatureExtractor(myfunc, target='y', **args) + output = FP.transform([y]) + + assert np.allclose(output, output_raw) + + # Ensure that fitting does nothing + FP.fit() + output = FP.transform([y]) + assert np.allclose(output, output_raw) + + def __test_keyword(myfunc, args): + + output_raw = myfunc(y=y, **args) + + FP = librosa.util.FeatureExtractor(myfunc, target='y', + iterate=False, **args) + output = FP.transform(y) + + assert np.allclose(output, output_raw) + + # Ensure that fitting does nothing + FP.fit() + output = FP.transform(y) + assert np.allclose(output, output_raw) + + func = librosa.feature.melspectrogram + args = {'sr': sr} + + for n_fft in [1024, 2048]: + for n_mels in [32, 64, 128]: + args['n_fft'] = n_fft + args['n_mels'] = n_mels + + yield __test_positional_iterate, func, args + yield __test_keyword_iterate, func, args + yield __test_positional, func, args + yield __test_keyword, func, args + + +def test_peak_pick(): + + def __test(n, pre_max, post_max, pre_avg, post_avg, delta, wait): + + # Generate a test signal + x = np.random.randn(n)**2 + + peaks = librosa.util.peak_pick(x, + pre_max, post_max, + pre_avg, post_avg, + delta, wait) + + for i in peaks: + # Test 1: is it a peak in this window? + s = i - pre_max + if s < 0: + s = 0 + t = i + post_max + + diff = x[i] - np.max(x[s:t]) + assert diff > 0 or np.isclose(diff, 0, rtol=1e-3, atol=1e-4) + + # Test 2: is it a big enough peak to count? + s = i - pre_avg + if s < 0: + s = 0 + t = i + post_avg + + diff = x[i] - (delta + np.mean(x[s:t])) + assert diff > 0 or np.isclose(diff, 0, rtol=1e-3, atol=1e-4) + + # Test 3: peak separation + assert not np.any(np.diff(peaks) <= wait) + + @raises(librosa.ParameterError) + def __test_shape_fail(): + x = np.eye(10) + librosa.util.peak_pick(x, 1, 1, 1, 1, 0.5, 1) + + yield __test_shape_fail + + win_range = [-1, 0, 1, 10] + + for n in [1, 5, 10, 100]: + for pre_max in win_range: + for post_max in win_range: + for pre_avg in win_range: + for post_avg in win_range: + for wait in win_range: + for delta in [-1, 0.05, 100.0]: + tf = __test + if pre_max < 0: + tf = raises(librosa.ParameterError)(__test) + if pre_avg < 0: + tf = raises(librosa.ParameterError)(__test) + if delta < 0: + tf = raises(librosa.ParameterError)(__test) + if wait < 0: + tf = raises(librosa.ParameterError)(__test) + if post_max <= 0: + tf = raises(librosa.ParameterError)(__test) + if post_avg <= 0: + tf = raises(librosa.ParameterError)(__test) + yield (tf, n, pre_max, post_max, + pre_avg, post_avg, delta, wait) + + +def test_sparsify_rows(): + + def __test(n, d, q): + + X = np.random.randn(*([d] * n))**4 + + X = np.asarray(X) + + xs = librosa.util.sparsify_rows(X, quantile=q) + + if ndim == 1: + X = X.reshape((1, -1)) + + assert np.allclose(xs.shape, X.shape) + + # And make sure that xs matches X on nonzeros + xsd = np.asarray(xs.todense()) + + for i in range(xs.shape[0]): + assert np.allclose(xsd[i, xs[i].indices], X[i, xs[i].indices]) + + # Compute row-wise magnitude marginals + v_in = np.sum(np.abs(X), axis=-1) + v_out = np.sum(np.abs(xsd), axis=-1) + + # Ensure that v_out retains 1-q fraction of v_in + assert np.all(v_out >= (1.0 - q) * v_in) + + for ndim in range(1, 4): + for d in [1, 5, 10, 100]: + for q in [-1, 0.0, 0.01, 0.25, 0.5, 0.99, 1.0, 2.0]: + tf = __test + if ndim not in [1, 2]: + tf = raises(librosa.ParameterError)(__test) + + if not 0.0 <= q < 1: + tf = raises(librosa.ParameterError)(__test) + + yield tf, ndim, d, q + + +def test_files(): + + # Expected output + output = [os.path.join(os.path.abspath(os.path.curdir), 'data', s) + for s in ['test1_22050.wav', + 'test1_44100.wav', + 'test2_8000.wav']] + + def __test(searchdir, ext, recurse, case_sensitive, limit, offset): + files = librosa.util.find_files(searchdir, + ext=ext, + recurse=recurse, + case_sensitive=case_sensitive, + limit=limit, + offset=offset) + + s1 = slice(offset, None) + s2 = slice(limit) + + assert set(files) == set(output[s1][s2]) + + for searchdir in [os.path.curdir, os.path.join(os.path.curdir, 'data')]: + for ext in [None, 'wav', 'WAV', ['wav'], ['WAV']]: + for recurse in [False, True]: + for case_sensitive in [False, True]: + for limit in [None, 1, 2]: + for offset in [0, 1, -1]: + tf = __test + + if searchdir == os.path.curdir and not recurse: + tf = raises(AssertionError)(__test) + + if (ext is not None and + case_sensitive and + (ext == 'WAV' or set(ext) == set(['WAV']))): + + tf = raises(AssertionError)(__test) + + yield (tf, searchdir, ext, recurse, + case_sensitive, limit, offset) + + +def test_valid_int(): + + def __test(x_in, cast): + z = librosa.util.valid_int(x_in, cast) + + assert isinstance(z, int) + if cast is None: + assert z == int(np.floor(x_in)) + else: + assert z == int(cast(x_in)) + + __test_fail = raises(librosa.ParameterError)(__test) + + for x in np.linspace(-2, 2, num=6): + for cast in [None, np.floor, np.ceil, 7]: + if cast is None or six.callable(cast): + yield __test, x, cast + else: + yield __test_fail, x, cast + + +def test_valid_intervals(): + + def __test(intval): + librosa.util.valid_intervals(intval) + + for d in range(1, 4): + for n in range(1, 4): + ivals = np.ones(d * [n]) + for m in range(1, 3): + slices = [slice(m)] * d + if m == 2 and d == 2 and n > 1: + yield __test, ivals[slices] + else: + yield raises(librosa.ParameterError)(__test), ivals[slices] + + +def test_warning_deprecated(): + + @librosa.util.decorators.deprecated('old_version', 'new_version') + def __dummy(): + return True + + warnings.resetwarnings() + warnings.simplefilter('always') + with warnings.catch_warnings(record=True) as out: + x = __dummy() + + # Make sure we still get the right value + assert x is True + + # And that the warning triggered + assert len(out) > 0 + + # And that the category is correct + assert out[0].category is DeprecationWarning + + # And that it says the right thing (roughly) + assert 'deprecated' in str(out[0].message).lower() + + +def test_warning_moved(): + + @librosa.util.decorators.moved('from', 'old_version', 'new_version') + def __dummy(): + return True + + warnings.resetwarnings() + warnings.simplefilter('always') + with warnings.catch_warnings(record=True) as out: + x = __dummy() + + # Make sure we still get the right value + assert x is True + + # And that the warning triggered + assert len(out) > 0 + + # And that the category is correct + assert out[0].category is DeprecationWarning + + # And that it says the right thing (roughly) + assert 'moved' in str(out[0].message).lower() + + +def test_warning_rename_kw_pass(): + + warnings.resetwarnings() + warnings.simplefilter('always') + + ov = librosa.util.Deprecated() + nv = 23 + + with warnings.catch_warnings(record=True) as out: + v = librosa.util.rename_kw('old', ov, 'new', nv, '0', '1') + + eq_(v, nv) + + # Make sure no warning triggered + assert len(out) == 0 + +def test_warning_rename_kw_fail(): + + warnings.resetwarnings() + warnings.simplefilter('always') + + ov = 27 + nv = 23 + + with warnings.catch_warnings(record=True) as out: + v = librosa.util.rename_kw('old', ov, 'new', nv, '0', '1') + + eq_(v, ov) + + # Make sure the warning triggered + assert len(out) > 0 + + # And that the category is correct + assert out[0].category is DeprecationWarning + + # And that it says the right thing (roughly) + assert 'renamed' in str(out[0].message).lower() + + +def test_index_to_slice(): + + def __test(idx, idx_min, idx_max, step, pad): + + slices = librosa.util.index_to_slice(idx, + idx_min=idx_min, + idx_max=idx_max, + step=step, + pad=pad) + + if pad: + if idx_min is not None: + eq_(slices[0].start, idx_min) + if idx.min() != idx_min: + slices = slices[1:] + if idx_max is not None: + eq_(slices[-1].stop, idx_max) + if idx.max() != idx_max: + slices = slices[:-1] + + if idx_min is not None: + idx = idx[idx >= idx_min] + + if idx_max is not None: + idx = idx[idx <= idx_max] + + idx = np.unique(idx) + eq_(len(slices), len(idx) - 1) + + for sl, start, stop in zip(slices, idx, idx[1:]): + eq_(sl.start, start) + eq_(sl.stop, stop) + eq_(sl.step, step) + + for indices in [np.arange(10, 90, 10), np.arange(10, 90, 15)]: + for idx_min in [None, 5, 15]: + for idx_max in [None, 85, 100]: + for step in [None, 2]: + for pad in [False, True]: + yield __test, indices, idx_min, idx_max, step, pad + + +def test_sync(): + + def __test_pass(axis, data, idx): + # By default, mean aggregation + dsync = librosa.util.sync(data, idx, axis=axis) + if data.ndim == 1 or axis == -1: + assert np.allclose(dsync, 2 * np.ones_like(dsync)) + else: + assert np.allclose(dsync, data) + + # Explicit mean aggregation + dsync = librosa.util.sync(data, idx, aggregate=np.mean, axis=axis) + if data.ndim == 1 or axis == -1: + assert np.allclose(dsync, 2 * np.ones_like(dsync)) + else: + assert np.allclose(dsync, data) + + # Max aggregation + dsync = librosa.util.sync(data, idx, aggregate=np.max, axis=axis) + if data.ndim == 1 or axis == -1: + assert np.allclose(dsync, 4 * np.ones_like(dsync)) + else: + assert np.allclose(dsync, data) + + # Min aggregation + dsync = librosa.util.sync(data, idx, aggregate=np.min, axis=axis) + if data.ndim == 1 or axis == -1: + assert np.allclose(dsync, np.zeros_like(dsync)) + else: + assert np.allclose(dsync, data) + + # Test for dtype propagation + assert dsync.dtype == data.dtype + + @raises(librosa.ParameterError) + def __test_fail(data, idx): + librosa.util.sync(data, idx) + + + for ndim in [1, 2, 3]: + shaper = [1] * ndim + shaper[-1] = -1 + + data = np.mod(np.arange(135), 5) + frames = np.flatnonzero(data[0] == 0) + slices = [slice(start, stop) for (start, stop) in zip(frames, frames[1:])] + data = np.reshape(data, shaper) + + for axis in [0, -1]: + # Test with list of indices + yield __test_pass, axis, data, list(frames) + # Test with ndarray of indices + yield __test_pass, axis, data, frames + # Test with list of slices + yield __test_pass, axis, data, slices + + for bad_idx in [ ['foo', 'bar'], [None], [slice(None), None] ]: + yield __test_fail, data, bad_idx