plant-soundwalk 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Brandon Mechtley
+
+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.rdoc

@@ -0,0 +1,15 @@
+# Soundwalk
+
+Soundwalk is a library for feature extraction, segmentation, and comparison of environmental (non-musical) sounds. 
+
+## requirements
+
+To install Soundwalk, it is necessary to have two libraries:
+1. FFTW (http://www.fftw.org/download.html) *Note:* 'fftw3f' is needed for float precision. Double precision (fftw3) is the default installation.
+2. libsndfile (http://www.mega-nerd.com/libsndfile/)
+
+*OSX Note:* Under OSX, you might get a warning about an unsupported architecture when compiling Soundwalk, since Ruby will try to create a universal binary for the bundle. This shouldn't matter, unless you want to copy the binary to another Mac with a different architecture. Alternatively, you can compile FFTW and libsndfile for the different architectures and use the `lipo` tool to combine them before compiling Soundwalk.
+
+# Copyright
+
+Copyright (c) 2009 Brandon Mechtley. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.files.include %w(lib/c/*.cpp lib/c/*.h lib/ruby/extconf.rb lib/ruby/*.cpp lib/ruby/*.h)
+    gem.files.exclude 'lib/ruby/soundwalk-api.rb'
+    gem.name = "soundwalk"
+    gem.summary = %Q{TODO}
+    gem.email = "bmechtley+github@gmail.com"
+    gem.homepage = "http://github.com/plant/soundwalk"
+    gem.authors = ["Brandon Mechtley"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "soundwalk-api #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/c/FeatureTemplate.cpp

@@ -0,0 +1,11 @@
+#include "FeatureTemplate.h"
+
+namespace SoundwalkLib {
+	FeatureTemplate::FeatureTemplate() {
+		
+	}
+	
+	FeatureTemplate::~FeatureTemplate() {
+		
+	}
+}

data/lib/c/FeatureTemplate.h

@@ -0,0 +1,24 @@
+/*
+	FeatureTemplate:
+		Class defining a "template" for a feature's trajectory in a sound.
+		This template (an HMM) is used to compare one sound with another sound.
+		
+		One sound's feature trajectory is run through the template of another sound
+		to compute the emission probability, that is the likelihood that the observed
+		feature trajectory can be explained by this template.
+*/
+
+#ifndef FEATURETEMPLATE_H
+#define FEATURETEMPLATE_H
+
+namespace SoundwalkLib {
+	class FeatureTemplate {
+	private:
+	
+	public:
+		FeatureTemplate();
+		~FeatureTemplate();
+	};
+}
+
+#endif

data/lib/c/Sound.cpp

@@ -0,0 +1,149 @@
+#include "Sound.h"
+
+#include "SoundFileExceptions.h"
+
+namespace SoundwalkLib {
+	Sound::Sound() {
+		soundFile = 0;
+	}
+	
+	Sound::~Sound() {
+		if (soundFile) {
+			sf_close(soundFile);
+			soundFile = 0;
+		}
+	}
+	
+	/*
+	 * Sound processing.
+	 */
+	
+	void Sound::openSound(string new_path) {
+		soundFile = sf_open(new_path.c_str(), SFM_READ, &soundFileInformation);
+		
+		if (soundFile) {
+			if (soundFileInformation.frames > 0) {
+				path = new_path;
+			} else {
+				sf_close(soundFile);
+				throw ExceptionEmptySoundFile();
+			}
+		} else 
+			throw ExceptionSoundFileLoadError(sf_error(soundFile));
+	}
+	
+	void Sound::extractFeatures() {
+		
+	}
+	
+	/*
+	 * Sound information.
+	 */
+	
+	void Sound::checkSoundFileOpen() {
+		if (!isOpen())
+			throw ExceptionSoundFileNotOpen();
+	}
+	
+	bool Sound::isOpen() {
+		if (soundFile)
+			return true;
+		else
+			return false;
+	}
+	
+	string Sound::getPath() {
+		checkSoundFileOpen();
+		return path;
+	}
+	
+	int Sound::getLength() {
+		checkSoundFileOpen();
+		return soundFileInformation.frames;
+	}
+	
+	int Sound::getSampleRate() {
+		checkSoundFileOpen();
+		return soundFileInformation.samplerate;
+	}
+	
+	int Sound::getChannels() {
+		checkSoundFileOpen();
+		return soundFileInformation.channels;
+	}
+	
+	int Sound::getFormat() {
+		checkSoundFileOpen();
+		return soundFileInformation.format;
+	}
+	
+	/*
+	 * Feature list manipulations.
+	 */
+	
+	void Sound::addCepstralFeature(Feature* feature) {
+		cepstralFeatures.push_back(feature);
+	}
+	
+	void Sound::addSpectralFeature(Feature* feature) {
+		spectralFeatures.push_back(feature);
+	}
+	
+	void Sound::addSampleFeature(Feature* feature) {
+		sampleFeatures.push_back(feature);
+	}
+	
+	void Sound::emptyCepstralFeatures() {
+		cepstralFeatures.empty();
+	}
+	
+	void Sound::emptySpectralFeatures() {
+		spectralFeatures.empty();
+	}
+	
+	void Sound::emptySampleFeatures() {
+		sampleFeatures.empty();
+	}
+	
+	void Sound::emptyAllFeatures() {
+		emptyCepstralFeatures();
+		emptySpectralFeatures();
+		emptySampleFeatures();
+	}
+	
+	vector<Feature*> Sound::getCepstralFeatures() {
+		return cepstralFeatures;
+	}
+	
+	vector<Feature*> Sound::getSpectralFeatures() {
+		return spectralFeatures;
+	}
+	
+	vector<Feature*> Sound::getSampleFeatures() {
+		return sampleFeatures;
+	}
+
+	/*
+	 * Spectrum properties.
+	 */
+	
+	void Sound::setSpectrumWindow(WindowFunction* window) {
+		spectrumWindow = window;
+	}
+	
+	void Sound::setFFTSize(int fft_size) {
+		fftSize = fft_size;
+	}
+	
+	int Sound::getFFTSize() {
+		return fftSize;
+	}
+	
+	void Sound::setMFCCSize(int mfcc_size) {
+		mfccSize = mfcc_size;
+	}
+	
+	int Sound::getMFCCSize() {
+		return mfccSize;
+	}
+}

data/lib/c/Sound.h

@@ -0,0 +1,75 @@
+#ifndef SOUND_H
+#define SOUND_H
+
+#include <vector>
+#include <string>
+using namespace std;
+
+#include "sndfile.h"
+
+namespace SoundwalkLib {	
+	class Feature;
+	class WindowFunction;
+	
+	class Sound {
+	protected:
+		// File information.
+		string path;
+		SNDFILE* soundFile;
+		SF_INFO soundFileInformation;
+		
+		// Features.
+		vector<float*> featureHistories;
+		
+		vector<Feature*> cepstralFeatures;
+		vector<Feature*> spectralFeatures;
+		vector<Feature*> sampleFeatures;
+		
+		// Frames
+		int hopSize;
+		int frameSize;
+		int fftSize;
+		int mfccSize;
+		
+		WindowFunction* spectrumWindow;
+		
+		void checkSoundFileOpen();
+		
+	public:
+		Sound();
+		~Sound();
+		
+		// Sound processing.
+		void openSound(string path);
+		void extractFeatures();
+		
+		// Sound information.
+		bool isOpen();
+		string getPath();
+		int getLength();
+		int getSampleRate();
+		int getChannels();
+		int getFormat();
+		
+		// Feature list manipulations.
+		void addCepstralFeature(Feature* feature);
+		void addSpectralFeature(Feature* feature);
+		void addSampleFeature(Feature* feature);
+		void emptyCepstralFeatures();
+		void emptySpectralFeatures();
+		void emptySampleFeatures();
+		void emptyAllFeatures();
+		vector<Feature*> getCepstralFeatures();
+		vector<Feature*> getSpectralFeatures();
+		vector<Feature*> getSampleFeatures();
+		
+		// Spectrum information.
+		void setSpectrumWindow(WindowFunction* window);
+		void setFFTSize(int fft_size);
+		void setMFCCSize(int mfcc_size);
+		int getFFTSize();
+		int getMFCCSize();
+	};
+}
+
+#endif

data/lib/c/SoundFileExceptions.h

@@ -0,0 +1,47 @@
+#ifndef SOUNDFILEEXCEPTIONS_H
+#define SOUNDFILEEXCEPTIONS_H
+
+#include <exception>
+using namespace std;
+
+namespace SoundwalkLib {
+	class ExceptionSoundFileNotOpen : public exception {
+	public:
+		virtual const char* what() const throw() {
+			return "Tried to perform an operation on a sound file that is not open.";
+		}
+	};
+	
+	class ExceptionSoundFileLoadError : public exception {
+	private:
+		int error;
+		
+	public:
+		ExceptionSoundFileLoadError(int new_error) {
+			error = new_error;
+		}
+		
+		virtual const char* what() const throw() {
+			if (error == SF_ERR_UNRECOGNISED_FORMAT)
+				return "Tried to open a file with unrecognized format.";
+			else if (error == SF_ERR_SYSTEM)
+				return "Tried to open a file that does not exist.";
+			else if (error == SF_ERR_MALFORMED_FILE)
+				return "Tried to open a malformed sound file.";
+			else if (error == SF_ERR_UNSUPPORTED_ENCODING)
+				return "Tried to open a sound file with unsupported encoding scheme.";
+			else
+				return "There was an unknown error opening the sound file.";
+		}
+	};
+
+	class ExceptionEmptySoundFile : public exception {
+	public:
+		virtual const char* what() const throw() {
+			return "Tried to open an empty sound file.";
+		}
+	};
+}
+
+
+#endif

data/lib/c/WindowFunctions.cpp

@@ -0,0 +1,15 @@
+#include "WindowFunctions.h"
+
+namespace SoundwalkLib {
+	float HannWindowFunction::apply(float input, int frame_size) {
+		return 0.5 * (1.0 - cos((2 * PI * input) / (float)(frame_size - 1)));
+	}
+
+	float HammingWindowFunction::apply(float input, int frame_size) {
+		return 0.54 - 0.46 * cos((2 * PI * input) / (float)(frame_size - 1));
+	}
+
+	float RectangularWindowFunction::apply(float input, int frame_size) {
+		return input;
+	}
+}

data/lib/c/WindowFunctions.h

@@ -0,0 +1,31 @@
+#ifndef WINDOWS_H
+#define WINDOWS_H
+
+#include <cmath>
+using namespace std;
+
+#define PI 3.14159265
+
+namespace SoundwalkLib {
+	class WindowFunction {
+	public:
+		virtual float apply(float input, int frame_size) = 0;
+	};
+	
+	class HannWindowFunction : public WindowFunction {
+	public:
+		virtual float apply(float input, int frame_size);
+	};
+	
+	class HammingWindowFunction : public WindowFunction {
+	public:
+		virtual float apply(float input, int frame_size);
+	};
+	
+	class RectangularWindowFunction : public WindowFunction {
+	public:
+		virtual float apply(float input, int frame_size);
+	};
+}
+
+#endif

data/lib/c/features/Feature.cpp

@@ -0,0 +1,15 @@
+#include "Feature.h"
+
+namespace SoundwalkLib {
+	void Feature::calculate(vector<float> values) {
+		value = 0;
+	}
+	
+	string Feature::toString() {
+		return "Feature";
+	}
+	
+	float Feature::getValue() {
+		return value;
+	}	
+}

data/lib/c/features/Feature.h

@@ -0,0 +1,20 @@
+#ifndef FEATURE_H
+#define FEATURE_H
+
+#include <vector>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	class Feature {
+	protected:
+		float value;
+	
+	public:
+		void calculate(vector<float> values);
+		string toString();
+		float getValue();
+	};
+}
+
+#endif

data/lib/c/features/HarmonicityFeature.cpp

@@ -0,0 +1,21 @@
+#include "HarmonicityFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void HarmonicityFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string HarmonicityFeature::toString() {
+		return string("Harmonicity");
+	}
+}

data/lib/c/features/HarmonicityFeature.h

@@ -0,0 +1,18 @@
+#ifndef HARMONICITYFEATURE_H
+#define HARMONICITYFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class HarmonicityFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();
+	};
+}
+
+#endif

data/lib/c/features/LoudnessFeature.cpp

@@ -0,0 +1,21 @@
+#include "LoudnessFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void LoudnessFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string LoudnessFeature::toString() {
+		return string("Loudness");
+	}
+}

data/lib/c/features/LoudnessFeature.h

@@ -0,0 +1,18 @@
+#ifndef LOUDNESSFEATURE_H
+#define LOUDNESSFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class LoudnessFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();
+	};
+}
+
+#endif

data/lib/c/features/SpectralCentroidFeature.cpp

@@ -0,0 +1,21 @@
+#include "SpectralCentroidFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void SpectralCentroidFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string SpectralCentroidFeature::toString() {
+		return string("Spectral Centroid");
+	}
+}

data/lib/c/features/SpectralCentroidFeature.h

@@ -0,0 +1,18 @@
+#ifndef SPECTRALCENTROIDFEATURE_H
+#define SPECTRALCENTROIDFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class SpectralCentroidFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();
+	};
+}
+
+#endif

data/lib/c/features/SpectralSparsityFeature.cpp

@@ -0,0 +1,21 @@
+#include "SpectralSparsityFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void SpectralSparsityFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string SpectralSparsityFeature::toString() {
+		return string("Spectral Sparsity");
+	}
+}

data/lib/c/features/SpectralSparsityFeature.h

@@ -0,0 +1,17 @@
+#ifndef SPECTRALSPARSITYFEATURE_H
+#define SPECTRALSPARSITYFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class SpectralSparsityFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();};
+}
+
+#endif

data/lib/c/features/TemporalSparsityFeature.cpp

@@ -0,0 +1,21 @@
+#include "TemporalSparsityFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void TemporalSparsityFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string TemporalSparsityFeature::toString() {
+		return string("Temporal Sparsity");
+	}
+}

data/lib/c/features/TemporalSparsityFeature.h

@@ -0,0 +1,18 @@
+#ifndef TEMPORALSPARSITYFEATURE_H
+#define TEMPORALSPARSITYFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class TemporalSparsityFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();
+	};
+}
+
+#endif

data/lib/c/features/TransientIndexFeature.cpp

@@ -0,0 +1,21 @@
+#include "TransientIndexFeature.h"
+
+#include <cmath>
+#include <string>
+using namespace std;
+
+namespace SoundwalkLib {
+	void TransientIndexFeature::calculate(vector<float> values) {
+		float rms = 0;
+	
+		for (int i = 0; i < values.size(); i++) {
+			rms += values[i] * values[i];
+		}
+	
+		value = 20 * log10(rms / (float) values.size());
+	}
+
+	string TransientIndexFeature::toString() {
+		return string("Transient Index");
+	}
+}

data/lib/c/features/TransientIndexFeature.h

@@ -0,0 +1,18 @@
+#ifndef TRANSIENTINDEXFEATURE_H
+#define TRANSIENTINDEXFEATURE_H
+
+#include "Feature.h"
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace SoundwalkLib {
+	class TransientIndexFeature : public Feature {
+	public:	
+		void calculate(vector<float> values);
+		string toString();
+	};
+}
+
+#endif

data/lib/ruby/extconf.rb

@@ -0,0 +1,26 @@
+require 'mkmf-rice'
+require 'FileUtils'
+
+$CFLAGS << " -I../c -I../c/features #{ENV['CFLAGS']}"
+
+extension_name = 'Soundwalk'
+
+%w[ ../c/features/HarmonicityFeature.cpp
+    ../c/features/TemporalSparsityFeature.cpp
+    ../c/features/SpectralSparsityFeature.cpp
+    ../c/features/SpectralCentroidFeature.cpp
+    ../c/features/LoudnessFeature.cpp
+    ../c/features/TransientIndexFeature.cpp
+    ../c/features/Feature.cpp
+    ../c/Sound.cpp
+    ../c/WindowFunctions.cpp
+].each do |filename|
+  abort "Error: #{filename} not found. Type 'make ruby' in the top directory.\n" unless File.exists? filename
+  FileUtils.cp(filename, ".")
+end
+
+have_library("sndfile")
+have_library("fftw3f")
+have_library("stdc++")
+
+create_makefile("soundwalk")

data/lib/ruby/soundwalk.cpp

@@ -0,0 +1,174 @@
+#include "rice/Class.hpp"
+#include "rice/String.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Array.hpp"
+using namespace Rice;
+
+#include "Sound.h"
+#include "Feature.h"
+#include "HarmonicityFeature.h"
+#include "LoudnessFeature.h"
+#include "SpectralCentroidFeature.h"
+#include "SpectralSparsityFeature.h"
+#include "TemporalSparsityFeature.h"
+#include "TransientIndexFeature.h"
+#include "WindowFunctions.h"
+#include "SoundFileExceptions.h"
+using namespace SoundwalkLib;
+
+vector<float> FloatVectorFromArray(Array array) {
+	vector<float> values;
+		
+	for (int i = 0; i < array.size(); i++)
+		values.push_back(NUM2DBL(array[i].value()));
+	
+	return values;
+}
+
+class RubyLoudnessFeature : public LoudnessFeature {
+public:
+	void calculate(Array array) {
+		LoudnessFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubyHarmonicityFeature : public HarmonicityFeature {
+public:
+	void calculate(Array array) {
+		HarmonicityFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubyTransientIndexFeature : public TransientIndexFeature {
+public:
+	void calculate(Array array) {
+		TransientIndexFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubySpectralCentroidFeature : public SpectralCentroidFeature {
+public:
+	void calculate(Array array) {
+		SpectralCentroidFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubySpectralSparsityFeature : public SpectralSparsityFeature {
+public:
+	void calculate(Array array) {
+		SpectralSparsityFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubyTemporalSparsityFeature : public TemporalSparsityFeature {
+public:
+	void calculate(Array array) {
+		TemporalSparsityFeature::calculate(FloatVectorFromArray(array));
+	}
+};
+
+class RubySound : public Sound {
+public:
+	Array cepstralFeaturesToArray() {
+		return Array(cepstralFeatures.begin(), cepstralFeatures.end());
+	}
+	
+	Array spectralFeaturesToArray() {
+		return Array(spectralFeatures.begin(), spectralFeatures.end());
+	}
+	
+	Array sampleFeaturesToArray() {
+		return Array(sampleFeatures.begin(), sampleFeatures.end());
+	}
+	
+	void cepstralFeaturesFromArray(Array new_features) {
+		emptyCepstralFeatures();
+		
+		for (int i = 0; i < new_features.size(); i++)
+			cepstralFeatures.push_back((Feature*)DATA_PTR(new_features[i].value()));
+	}
+	
+	void spectralFeaturesFromArray(Array new_features) {
+		emptySpectralFeatures();
+		
+		for (int i = 0; i < new_features.size(); i++)
+			spectralFeatures.push_back((Feature*)DATA_PTR(new_features[i].value()));
+	}
+	
+	void sampleFeaturesFromArray(Array new_features) {
+		emptySampleFeatures();
+		
+		for (int i = 0; i < new_features.size(); i++)
+			sampleFeatures.push_back((Feature*)DATA_PTR(new_features[i].value()));
+	}
+};
+	
+Array rb_cSoundFeatures() {
+	return Array();
+}
+
+extern "C" void Init_soundwalk() {
+	Data_Type<Sound> rb_cSound = 
+		define_class<RubySound>("Sound")
+		.define_constructor(Constructor<RubySound>())
+		.define_method("length", &RubySound::getLength)
+		.define_method("sampleRate", &RubySound::getSampleRate)
+		.define_method("channels", &RubySound::getChannels)
+		.define_method("format", &RubySound::getFormat)
+		.define_method("path", &RubySound::getPath)
+		.define_method("fftSize=", &RubySound::setFFTSize)
+		.define_method("fftSize", &RubySound::getFFTSize)
+		.define_method("mfccSize=", &RubySound::setMFCCSize)
+		.define_method("mfccSize", &RubySound::getMFCCSize)
+		.define_method("openSound", &RubySound::openSound)
+		.define_method("cepstralFeatures", &RubySound::cepstralFeaturesToArray)
+		.define_method("cepstralFeatures=", &RubySound::cepstralFeaturesFromArray)
+		.define_method("spectralFeatures", &RubySound::spectralFeaturesToArray)
+		.define_method("spectralFeatures=", &RubySound::spectralFeaturesFromArray)
+		.define_method("sampleFeatures", &RubySound::sampleFeaturesToArray)
+		.define_method("sampleFeatures=", &RubySound::sampleFeaturesFromArray);
+		
+	Data_Type<Feature> rb_cFeature = 
+		define_class<Feature>("Feature")
+		.define_constructor(Constructor<Feature>())
+		.define_method("value", &Feature::getValue)
+		.define_method("calculate", &Feature::calculate)
+		.define_method("toString", &Feature::toString);
+	
+	Data_Type<RubyLoudnessFeature> rb_cLoudnessFeature = 
+		define_class<RubyLoudnessFeature, Feature>("LoudnessFeature")
+		.define_constructor(Constructor<RubyLoudnessFeature>())
+		.define_method("calculate", &RubyLoudnessFeature::calculate)
+		.define_method("toString", &RubyLoudnessFeature::toString);
+		
+	Data_Type<RubyHarmonicityFeature> rb_cHarmonicityFeature = 
+		define_class<RubyHarmonicityFeature, Feature>("HarmonicityFeature")
+		.define_constructor(Constructor<RubyHarmonicityFeature>())
+		.define_method("calculate", &RubyHarmonicityFeature::calculate)
+		.define_method("toString", &RubyHarmonicityFeature::toString);
+		
+	Data_Type<RubyTransientIndexFeature> rb_cTransientIndexFeature = 
+		define_class<RubyTransientIndexFeature, Feature>("TransientIndexFeature")
+		.define_constructor(Constructor<RubyTransientIndexFeature>())
+		.define_method("calculate", &RubyTransientIndexFeature::calculate)
+		.define_method("toString", &RubyTransientIndexFeature::toString);
+		
+	Data_Type<RubySpectralCentroidFeature> rb_cSpectralCentroidFeature = 
+		define_class<RubySpectralCentroidFeature, Feature>("SpectralCentroidFeature")
+		.define_constructor(Constructor<RubySpectralCentroidFeature>())
+		.define_method("calculate", &RubySpectralCentroidFeature::calculate)
+		.define_method("toString", &RubySpectralCentroidFeature::toString);
+		
+	Data_Type<RubySpectralSparsityFeature> rb_cSpectralSparsityFeature = 
+		define_class<RubySpectralSparsityFeature, Feature>("SpectralSparsityFeature")
+		.define_constructor(Constructor<RubySpectralSparsityFeature>())
+		.define_method("calculate", &RubySpectralSparsityFeature::calculate)
+		.define_method("toString", &RubySpectralSparsityFeature::toString);
+			
+	Data_Type<RubyTemporalSparsityFeature> rb_cTemporalSparsityFeature = 
+		define_class<RubyTemporalSparsityFeature, Feature>("TemporalSparsityFeature")
+		.define_constructor(Constructor<RubyTemporalSparsityFeature>())
+		.define_method("calculate", &RubyTemporalSparsityFeature::calculate)
+		.define_method("toString", &RubyTemporalSparsityFeature::toString);
+}

data/lib/ruby/soundwalk.rb

@@ -0,0 +1,27 @@
+require 'soundwalk'
+
+filename = '/Users/brandon/Desktop/segment_10.wav'
+s = Sound.new
+s.openSound filename
+
+print "\n", s
+print "\n\tPath: ", s.path
+print "\n\tChannels: ", s.channels
+print "\n\tFormat: ", s.format
+print "\n\tLength: ", s.length
+print "\n\tSample rate: ", s.sampleRate
+print "\n\n\n"
+
+sampleFeatures = Array[LoudnessFeature.new, TemporalSparsityFeature.new]
+cepstralFeatures = Array[SpectralCentroidFeature.new, TransientIndexFeature.new]
+spectralFeatures = Array[HarmonicityFeature.new, SpectralSparsityFeature.new]
+
+s.sampleFeatures = sampleFeatures
+s.cepstralFeatures = cepstralFeatures
+s.spectralFeatures = spectralFeatures
+
+print "\n", s.sampleFeatures
+print "\n", s.cepstralFeatures
+print "\n", s.spectralFeatures
+
+print "\n\n\n"

data/soundwalk.gemspec

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{soundwalk}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brandon Mechtley"]
+  s.date = %q{2009-05-22}
+  s.email = %q{bmechtley+github@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/c/FeatureTemplate.cpp",
+     "lib/c/FeatureTemplate.cpp",
+     "lib/c/FeatureTemplate.h",
+     "lib/c/FeatureTemplate.h",
+     "lib/c/Sound.cpp",
+     "lib/c/Sound.cpp",
+     "lib/c/Sound.h",
+     "lib/c/Sound.h",
+     "lib/c/SoundFileExceptions.h",
+     "lib/c/SoundFileExceptions.h",
+     "lib/c/WindowFunctions.cpp",
+     "lib/c/WindowFunctions.cpp",
+     "lib/c/WindowFunctions.h",
+     "lib/c/WindowFunctions.h",
+     "lib/c/features/Feature.cpp",
+     "lib/c/features/Feature.h",
+     "lib/c/features/HarmonicityFeature.cpp",
+     "lib/c/features/HarmonicityFeature.h",
+     "lib/c/features/LoudnessFeature.cpp",
+     "lib/c/features/LoudnessFeature.h",
+     "lib/c/features/SpectralCentroidFeature.cpp",
+     "lib/c/features/SpectralCentroidFeature.h",
+     "lib/c/features/SpectralSparsityFeature.cpp",
+     "lib/c/features/SpectralSparsityFeature.h",
+     "lib/c/features/TemporalSparsityFeature.cpp",
+     "lib/c/features/TemporalSparsityFeature.h",
+     "lib/c/features/TransientIndexFeature.cpp",
+     "lib/c/features/TransientIndexFeature.h",
+     "lib/ruby/extconf.rb",
+     "lib/ruby/extconf.rb",
+     "lib/ruby/soundwalk.cpp",
+     "lib/ruby/soundwalk.cpp",
+     "lib/ruby/soundwalk.rb",
+     "soundwalk.gemspec",
+     "test/soundwalk-api_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/plant/soundwalk}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Gem for feature extraction, segmentation, and comparison of environmental (non-musical) sounds.}
+  s.test_files = [
+    "test/soundwalk-api_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/soundwalk-api_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class SoundwalkApiTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'soundwalk-api'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: plant-soundwalk
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Brandon Mechtley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-22 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: bmechtley+github@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/c/FeatureTemplate.cpp
+- lib/c/FeatureTemplate.h
+- lib/c/Sound.cpp
+- lib/c/Sound.h
+- lib/c/SoundFileExceptions.h
+- lib/c/WindowFunctions.cpp
+- lib/c/WindowFunctions.h
+- lib/c/features/Feature.cpp
+- lib/c/features/Feature.h
+- lib/c/features/HarmonicityFeature.cpp
+- lib/c/features/HarmonicityFeature.h
+- lib/c/features/LoudnessFeature.cpp
+- lib/c/features/LoudnessFeature.h
+- lib/c/features/SpectralCentroidFeature.cpp
+- lib/c/features/SpectralCentroidFeature.h
+- lib/c/features/SpectralSparsityFeature.cpp
+- lib/c/features/SpectralSparsityFeature.h
+- lib/c/features/TemporalSparsityFeature.cpp
+- lib/c/features/TemporalSparsityFeature.h
+- lib/c/features/TransientIndexFeature.cpp
+- lib/c/features/TransientIndexFeature.h
+- lib/ruby/extconf.rb
+- lib/ruby/soundwalk.cpp
+- lib/ruby/soundwalk.rb
+- soundwalk.gemspec
+- test/soundwalk-api_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/plant/soundwalk
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Gem for feature extraction, segmentation, and comparison of environmental (non-musical) sounds.
+test_files: 
+- test/soundwalk-api_test.rb
+- test/test_helper.rb