RubyGems - vocal_tract_length - Versions diffs - 1.0.0 - Mend

vocal_tract_length 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

checksums.yaml +7 -0
data/.gitignore +14 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +24 -0
data/Rakefile +2 -0
data/config.ru +3 -0
data/lib/public/frequency.png +0 -0
data/lib/public/index.html +174 -0
data/lib/public/length.png +0 -0
data/lib/public/recorder.js +89 -0
data/lib/public/recorderWorker.js +131 -0
data/lib/vocal_tract_length/version.rb +3 -0
data/lib/vocal_tract_length.rb +10 -0
data/vocal_tract_length.gemspec +24 -0
metadata +114 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1807e5f276002fa0b457c2097660cc3e842856be
+  data.tar.gz: e065811735ab6fcaf704942a9e70e0be484d14e3
+SHA512:
+  metadata.gz: a6abf0acca943104437bd2d9ce179feed3f87eca7d6600c3070a8df70cd95199400acf6d084d5a8ca4e8f01ee0a8703f06ea333e4c649dc4d679220f37bfa692
+  data.tar.gz: 0df030b9089c01e570e5126bc6c19ce734f2c951e015fbce5f77d5f09afc4dea87f2c673929791f16336743a624870658ce06d82816ca6ad9aa6f20c28ae61a6

data/.gitignore ADDED Viewed

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile ADDED Viewed

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in vocal_tract_length.gemspec
+gemspec

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Max Holder
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED Viewed

@@ -0,0 +1,24 @@
+# Vocal Tract Length
+This small Sinatra application provides the frontend for users to record their
+voice in order to calculate the length of their vocal tract.
+See it in action at:
+[http://maxwellholder.com/vocal_tract_length/index.html](http://maxwellholder.com/vocal_tract_length/index.html)
+# Backend
+To see the [Praat](http://praat.org) script and the Sinatra extension that provides the
+`/extract_formant1` route, see the
+[sinatra-praat](https://github.com/mxhold/sinatra-praat) project.
+# How to Run
+1. Install a recent version of [Ruby](https://ruby-lang.org)
+2. Install [Praat](http://praat.org) and add it to your $PATH
+3. Clone the project: `git clone https://github.com/mxhold/vocal_tract_length`
+4. Run `bundle install`
+5. Run `rackup`
+6. It should be running at
+   [http://localhost:9292/vocal_tract_length/index.html](http://localhost:9292/vocal_tract_length/index.html)

data/Rakefile ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ require "bundler/gem_tasks"
2	+

data/config.ru ADDED Viewed

@@ -0,0 +1,3 @@
+require 'vocal_tract_length'
+run VocalTractLength::App

data/lib/public/frequency.png ADDED Viewed

Binary file

data/lib/public/index.html ADDED Viewed

@@ -0,0 +1,174 @@
+<html>
+<head>
+  <title>Calculate Your Vocal Tract Length</title>
+  <script>
+    var audio_context;
+    var recorder;
+    window.onload = function init() {
+      try {
+        // webkit shim
+        window.AudioContext = window.AudioContext || window.webkitAudioContext;
+        navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia;
+        window.URL = window.URL || window.webkitURL;
+        audio_context = new AudioContext;
+        navigator.getUserMedia({audio: true}, startUserMedia, function(e) {
+          console.log('No live audio input: ' + e);
+        });
+      } catch (e) {
+        alert('No web audio support in this browser!');
+      }
+    };
+    function startUserMedia(stream) {
+      var input = audio_context.createMediaStreamSource(stream);
+      recorder = new Recorder(input);
+      document.querySelector("[data-id=allowHint]").style.display = 'none';
+      startRecordingButton = document.querySelector("[data-action=startRecording]");
+      startRecordingButton.disabled = false;
+      startRecordingButton.addEventListener("click", startRecording, false);
+      console.log("bound");
+    }
+    function startRecording() {
+      this.innerHTML = "Recording... "
+      this.disabled = true;
+      recorder && recorder.record();
+      setTimeout(stopRecording, 2000, this);
+    }
+    function stopRecording(button) {
+      button.innerHTML = "Record"
+      button.disabled = false;
+      recorder && recorder.stop();
+      recorder.exportWAV(sendWAV);
+    }
+    function calculateVocalTractLength(formant1) {
+      return 34400 / (4.0 * formant1);
+    }
+    function roundTo(number, places) {
+      return Math.round(number * Math.pow(10, places))/Math.pow(10, places);
+    }
+    function setFormant1Result(formant1Text) {
+      formant1 = parseFloat(formant1Text);
+      document.querySelector("[data-id=formant1]").innerHTML = roundTo(formant1, 0);
+      document.querySelector("[data-id=vocalTractLength]").innerHTML = roundTo(calculateVocalTractLength(formant1), 1);
+      document.querySelector("[data-id=results]").style.display = 'initial';
+    }
+    function sendWAV(blob) {
+      var formData = new FormData();
+      formData.append('data', blob);
+      xhr = new XMLHttpRequest();
+      xhr.open("POST", "extract_formant1", true);
+      xhr.onload = function() {
+        setFormant1Result(xhr.responseText);
+      }
+      xhr.send(formData);
+      recorder.clear();
+    }
+  </script>
+  <script src="recorder.js"></script>
+</head>
+<body>
+  <nav>
+    <a href="/">Home</a>
+    <a href="https://github.com/mxhold/vocal_tract_length">Source code</a>
+  </nav>
+  <section>
+    <h1>Calculate Your Vocal Tract Length</h1>
+    <p>
+      Click <em>Record</em> and produce an unobstructed vowel (the last sound in
+      the English word <em>comma</em>) continuously for 2 seconds.
+    </p>
+    <p data-id="allowHint">
+      <em>First, click "Allow" in your browser to let this page to record your
+        voice.</em>
+    </p>
+    <p>
+      <button data-action="startRecording" disabled>Record</button>
+    </p>
+  </section>
+  <section data-id="results" style="display: none;">
+    <h1>Results</h1>
+    <p>
+      F<sub>1</sub> = <span data-id="formant1">error</span> Hz
+    </p>
+    <p>
+      Estimated vocal tract length:
+      <span data-id="vocalTractLength">error</span> cm
+    </p>
+    <p>
+      Average vocal tract length (female): 14.1 cm<br>
+      Average vocal tract length (male): 17 cm<br>
+    </p>
+  </section>
+  <section>
+    <h1>About</h1>
+    <p>
+      If we simplify things significantly, the human vocal tract is really just
+      a tube that is closed on one end (where your vocal folds vibrate) and open
+      on another end (your lips).
+    </p>
+    <p>
+      Given this model, there is a formula that expresses the relationship
+      between resonance frequencies (<em>f</em>, which we is what we are
+      measuring here), the speed of sound (<em>v</em>, which we know), and the
+      length of the tube (<em>L</em>, which is what we are trying to figure
+      out):
+    </p>
+    <img src="frequency.png" alt="f = nv/2L" height="50">
+    <p>
+      The <em>n</em> here refers to which resonance frequency we're talking
+      about. Vowels will usually have four or more distinguishable resonance
+      frequencies, but we're just dealing with the first (F<sub>1</sub>) here,
+      so we can replace this with 1. We can also replace <em>v</em> with 34400
+      cm/s since we know that's the speed of sound at sea level at room
+      temperature (20&deg;C). And since we know the frequency but want to
+      determine the length, we can solve for L to get this equation:
+    </p>
+    <img src="length.png" alt="L = 34400/4f" height="50">
+    <h2>How are you measuring F<sub>1</sub>?</h2>
+    <p>
+      When you hit record, we are using a Javascript library that wraps the
+      browser's audio recording API to record a 2 second WAV audio clip.
+      Thanks to
+      <a href="http://matt-diamond.com/">Matt Diamond's</a>
+      <a href="https://github.com/mattdiamond/Recorderjs">Recorderjs project</a>
+      for making that library.
+    </p>
+    <p>
+      This data is then sent to the server where it is processed using <a
+         href="http://praat.org">Praat</a>, a seriously cool program that can do
+       all sorts of phonetic analysis. This gives us the first formant which we
+       then plug into the above equation.
+    </p>
+    <p>
+      You can see the source code for this page and the server side Praat script
+      on <a href="https://github.com/mxhold/vocal_tract_length">GitHub</a>.
+    </p>
+    <h2>Is this accurate? Why is the estimate so inconsistent?</h2>
+    <p>
+      It is pretty hard to get people to produce an unobstructed vowel
+      consistently so that is probably the biggest limitation with this method.
+      We're also using a simplified model of the vocal tract, likely using a
+      less than perfect microphone, and only taking a 2 second sample.
+    </p>
+    <p>
+      The point of this is not to actually give you an accurate measure, but
+      rather to show it's possible to calculate the length of the vocal tract
+      from a recording, which I think is pretty cool.
+    </p>
+  </section>
+</body>
+</html>

data/lib/public/length.png ADDED Viewed

Binary file

data/lib/public/recorder.js ADDED Viewed

@@ -0,0 +1,89 @@
+(function(window){
+  var WORKER_PATH = 'recorderWorker.js';
+  var Recorder = function(source, cfg){
+    var config = cfg || {};
+    var bufferLen = config.bufferLen || 4096;
+    this.context = source.context;
+    this.node = (this.context.createScriptProcessor ||
+                 this.context.createJavaScriptNode).call(this.context,
+                                                         bufferLen, 2, 2);
+    var worker = new Worker(config.workerPath || WORKER_PATH);
+    worker.postMessage({
+      command: 'init',
+      config: {
+        sampleRate: this.context.sampleRate
+      }
+    });
+    var recording = false,
+      currCallback;
+    this.node.onaudioprocess = function(e){
+      if (!recording) return;
+      worker.postMessage({
+        command: 'record',
+        buffer: [
+          e.inputBuffer.getChannelData(0),
+          e.inputBuffer.getChannelData(1)
+        ]
+      });
+    }
+    this.configure = function(cfg){
+      for (var prop in cfg){
+        if (cfg.hasOwnProperty(prop)){
+          config[prop] = cfg[prop];
+        }
+      }
+    }
+    this.record = function(){
+      recording = true;
+    }
+    this.stop = function(){
+      recording = false;
+    }
+    this.clear = function(){
+      worker.postMessage({ command: 'clear' });
+    }
+    this.getBuffer = function(cb) {
+      currCallback = cb || config.callback;
+      worker.postMessage({ command: 'getBuffer' })
+    }
+    this.exportWAV = function(cb, type){
+      currCallback = cb || config.callback;
+      type = type || config.type || 'audio/wav';
+      if (!currCallback) throw new Error('Callback not set');
+      worker.postMessage({
+        command: 'exportWAV',
+        type: type
+      });
+    }
+    worker.onmessage = function(e){
+      var blob = e.data;
+      currCallback(blob);
+    }
+    source.connect(this.node);
+    this.node.connect(this.context.destination);    //this should not be necessary
+  };
+  Recorder.forceDownload = function(blob, filename){
+    var url = (window.URL || window.webkitURL).createObjectURL(blob);
+    var link = window.document.createElement('a');
+    link.href = url;
+    link.download = filename || 'output.wav';
+    var click = document.createEvent("Event");
+    click.initEvent("click", true, true);
+    link.dispatchEvent(click);
+  }
+  window.Recorder = Recorder;
+})(window);

data/lib/public/recorderWorker.js ADDED Viewed

@@ -0,0 +1,131 @@
+var recLength = 0,
+  recBuffersL = [],
+  recBuffersR = [],
+  sampleRate;
+this.onmessage = function(e){
+  switch(e.data.command){
+    case 'init':
+      init(e.data.config);
+      break;
+    case 'record':
+      record(e.data.buffer);
+      break;
+    case 'exportWAV':
+      exportWAV(e.data.type);
+      break;
+    case 'getBuffer':
+      getBuffer();
+      break;
+    case 'clear':
+      clear();
+      break;
+  }
+};
+function init(config){
+  sampleRate = config.sampleRate;
+}
+function record(inputBuffer){
+  recBuffersL.push(inputBuffer[0]);
+  recBuffersR.push(inputBuffer[1]);
+  recLength += inputBuffer[0].length;
+}
+function exportWAV(type){
+  var bufferL = mergeBuffers(recBuffersL, recLength);
+  var bufferR = mergeBuffers(recBuffersR, recLength);
+  var interleaved = interleave(bufferL, bufferR);
+  var dataview = encodeWAV(interleaved);
+  var audioBlob = new Blob([dataview], { type: type });
+  this.postMessage(audioBlob);
+}
+function getBuffer() {
+  var buffers = [];
+  buffers.push( mergeBuffers(recBuffersL, recLength) );
+  buffers.push( mergeBuffers(recBuffersR, recLength) );
+  this.postMessage(buffers);
+}
+function clear(){
+  recLength = 0;
+  recBuffersL = [];
+  recBuffersR = [];
+}
+function mergeBuffers(recBuffers, recLength){
+  var result = new Float32Array(recLength);
+  var offset = 0;
+  for (var i = 0; i < recBuffers.length; i++){
+    result.set(recBuffers[i], offset);
+    offset += recBuffers[i].length;
+  }
+  return result;
+}
+function interleave(inputL, inputR){
+  var length = inputL.length + inputR.length;
+  var result = new Float32Array(length);
+  var index = 0,
+    inputIndex = 0;
+  while (index < length){
+    result[index++] = inputL[inputIndex];
+    result[index++] = inputR[inputIndex];
+    inputIndex++;
+  }
+  return result;
+}
+function floatTo16BitPCM(output, offset, input){
+  for (var i = 0; i < input.length; i++, offset+=2){
+    var s = Math.max(-1, Math.min(1, input[i]));
+    output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7FFF, true);
+  }
+}
+function writeString(view, offset, string){
+  for (var i = 0; i < string.length; i++){
+    view.setUint8(offset + i, string.charCodeAt(i));
+  }
+}
+function encodeWAV(samples){
+  var buffer = new ArrayBuffer(44 + samples.length * 2);
+  var view = new DataView(buffer);
+  /* RIFF identifier */
+  writeString(view, 0, 'RIFF');
+  /* RIFF chunk length */
+  view.setUint32(4, 36 + samples.length * 2, true);
+  /* RIFF type */
+  writeString(view, 8, 'WAVE');
+  /* format chunk identifier */
+  writeString(view, 12, 'fmt ');
+  /* format chunk length */
+  view.setUint32(16, 16, true);
+  /* sample format (raw) */
+  view.setUint16(20, 1, true);
+  /* channel count */
+  view.setUint16(22, 2, true);
+  /* sample rate */
+  view.setUint32(24, sampleRate, true);
+  /* byte rate (sample rate * block align) */
+  view.setUint32(28, sampleRate * 4, true);
+  /* block align (channel count * bytes per sample) */
+  view.setUint16(32, 4, true);
+  /* bits per sample */
+  view.setUint16(34, 16, true);
+  /* data chunk identifier */
+  writeString(view, 36, 'data');
+  /* data chunk length */
+  view.setUint32(40, samples.length * 2, true);
+  floatTo16BitPCM(view, 44, samples);
+  return view;
+}

data/lib/vocal_tract_length/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module VocalTractLength
+  VERSION = "1.0.0"
+end

data/lib/vocal_tract_length.rb ADDED Viewed

@@ -0,0 +1,10 @@
+require 'sinatra/base'
+require 'sinatra/praat'
+module VocalTractLength
+  class App < Sinatra::Base
+    register Sinatra::Praat
+    set :public_folder, __dir__ + '/public'
+  end
+end

data/vocal_tract_length.gemspec ADDED Viewed

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vocal_tract_length/version'
+Gem::Specification.new do |spec|
+  spec.name          = "vocal_tract_length"
+  spec.version       = VocalTractLength::VERSION
+  spec.authors       = ["Max Holder"]
+  spec.email         = ["mxhold@gmail.com"]
+  spec.summary       = %q{Calculate your vocal tract length by recording your voice}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency 'sinatra'
+  spec.add_dependency 'sinatra-praat'
+end

metadata ADDED Viewed

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: vocal_tract_length
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Max Holder
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-praat
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- mxhold@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config.ru
+- lib/public/frequency.png
+- lib/public/index.html
+- lib/public/length.png
+- lib/public/recorder.js
+- lib/public/recorderWorker.js
+- lib/vocal_tract_length.rb
+- lib/vocal_tract_length/version.rb
+- vocal_tract_length.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Calculate your vocal tract length by recording your voice
+test_files: []