plant-sirens-ruby 0.0.1

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.markdown

@@ -0,0 +1,45 @@
+# sirens-ruby
+sirens-ruby is a ruby extension for [Sirens](http://github.com/plant/sirens), a library for segmentation, indexing, and retrieval of environmental and natural sounds. Sirens is currently under development and only supports basic feature extraction. Please check back for updates.
+
+## Requirements
+To install sirens-ruby, it is necessary to have the three libraries:
+
+1. [FFTW](http://www.fftw.org/download.html)
+2. [STK](http://ccrma.stanford.edu/software/stk/)
+3. [Sirens](http://github.com/plant/sirens)
+
+## Installation
+To install Soundwalk, perform the following steps.
+
+1. `git clone git://github.com/plant/sirens-ruby.git`
+2. `cd sirens-ruby`
+3. `rake compile`
+4. `rake build`
+
+*OSX Note:* Under OSX, you might get a warning about an unsupported architecture when compiling sirens-ruby, since Ruby will try to create a universal binary for the bundle, and FFTW and STK don't build universal binaries by default. For STK, in the future I may just include the necessary source in [Sirens](http://github.com/plant/sirens) rather than linking against a library, as is conventional.
+
+## Usage
+Sirens is pretty minimal at the moment and only supports the extraction of six basic features. In the future, Sirens will include feature-based segmentation and comparison.
+
+Here is a basic example to extract loudness (dB) values from a sound file:
+	require 'sirens'
+	
+	s = Sirens::Sound.new
+  	s.frameLength = 0.04
+  	s.hopLength = 0.02
+  	
+	loudness = Sirens::LoudnessFeature.new
+  	loudness.historySize = s.frames
+    
+	s.sampleFeatures = Array[loudness]
+	
+	s.extractFeatures
+	
+	for value in loudness.history
+		puts value
+	end
+
+More detailed documentation is on the Wiki (http://wiki.github.com/plant/sirens-ruby). You can also check out `test/soundwalk_test.rb` for an example of extracting all six features with some default parameters.
+
+# Copyright
+Copyright (c) 2009 Brandon Mechtley. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  spec = Jeweler::Tasks.new do |gem|
+    gem.files.include %w(ext/ruby/extconf.rb ext/ruby/sirens-ruby.cpp)
+    gem.name = "sirens-ruby"
+    gem.summary = "Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds."
+    gem.description = "Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds."
+    gem.email = "bmechtley+github@gmail.com"
+    gem.homepage = "http://github.com/plant/sirens-ruby"
+    gem.authors = ["Brandon Mechtley"]
+    gem.extensions = FileList["ext/**/extconf.rb"]
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Rake::GemPackageTask.new(spec.gemspec) do |pkg|
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('sirens', spec.gemspec)
+
+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 = "sirens #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ext/sirens/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf-rice'
+require 'FileUtils'
+
+$CFLAGS << "#{ENV['CFLAGS']} -D__OS_MACOSX__"
+
+have_library('sirens')
+have_library('stk')
+have_library('fftw3')
+
+create_makefile('sirens')

data/ext/sirens/sirens.cpp

@@ -0,0 +1,158 @@
+#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 "sirens/Sound.h"
+#include "sirens/CircularArray.h"
+#include "sirens/LoudnessFeature.h"
+#include "sirens/HarmonicityFeature.h"
+#include "sirens/TransientIndexFeature.h"
+#include "sirens/SpectralCentroidFeature.h"
+#include "sirens/SpectralSparsityFeature.h"
+#include "sirens/TemporalSparsityFeature.h"
+using namespace Sirens;
+
+template <>
+Object to_ruby<CircularArray*>(CircularArray* const & x) {
+	Array y;
+	
+	for (int i = 0; i < x->getSize(); i++)
+		y.push(x->getValueAt(i));
+	
+	return y;
+}
+
+template <> 
+Object to_ruby<vector<Feature*> >(vector<Feature*> const & x) {
+	return Array(x.begin(), x.end());
+}
+
+template <>
+vector<Feature*> from_ruby<vector<Feature*> >(Object x) {
+	vector<Feature*> y;
+	
+	Array new_features(x);
+	
+	for (unsigned int i = 0; i < new_features.size(); i++)
+		y.push_back((Feature*)DATA_PTR(new_features[i].value()));
+		
+	return y;
+}
+
+float rb_mFeatureValue () {
+	return 0;
+}
+
+void rb_mFeatureCalculate() {
+	
+}
+
+Array rb_mFeatureHistory() {
+	return Array();
+}
+
+string rb_mFeatureToString() {
+	return "Feature";
+}
+	
+Array rb_cSoundFeatures() {
+	return Array();
+}
+
+extern "C" void Init_sirens() {
+	Module rb_mSirens = define_module("Sirens");
+	
+	Data_Type<Sound> rb_cSound = 
+		define_class_under<Sound>(rb_mSirens, "Sound")
+		.define_constructor(Constructor<Sound>())
+		.define_method("open", &Sound::open)
+		.define_method("samples", &Sound::getSampleCount)
+		.define_method("frames", &Sound::getFrameCount)
+		.define_method("frameLength", &Sound::getFrameLength)
+		.define_method("frameLength=", &Sound::setFrameLength)
+		.define_method("hopLength", &Sound::getHopLength)
+		.define_method("hopLength=", &Sound::setHopLength)
+		.define_method("samplesPerFrame", &Sound::getSamplesPerFrame)
+		.define_method("samplesPerHop", &Sound::getSamplesPerHop)
+		.define_method("sampleRate", &Sound::getSampleRate)
+		.define_method("fftSize", &Sound::getFFTSize)
+		.define_method("spectrumSize", &Sound::getSpectrumSize)
+		.define_method("path", &Sound::getPath)
+		.define_method("extractFeatures", &Sound::extractFeatures)
+		.define_method("saveFeaturesCSV", &Sound::saveFeaturesCSV)
+		.define_method("spectralFeatures", &Sound::getSpectralFeatures)
+		.define_method("spectralFeatures=", &Sound::setSpectralFeatures)
+		.define_method("spectralFeatures[]", &Sound::getSpectralFeatureAt)
+		.define_method("sampleFeatures", &Sound::getSampleFeatures)
+		.define_method("sampleFeatures=", &Sound::setSampleFeatures)
+		.define_method("sampleFeatures[]", &Sound::getSampleFeatureAt);
+		
+	Data_Type<Feature> rb_cFeature = 
+		define_class_under<Feature>(rb_mSirens, "Feature")
+		.define_constructor(Constructor<Feature>())
+		.define_method("to_s", &Feature::toString)
+		.define_method("history", &Feature::getHistory)
+		.define_method("history[]", &Feature::getHistoryFrame)
+		.define_method("historySize", &Feature::getHistorySize)
+		.define_method("historySize=", &Feature::setHistorySize)
+		.define_method("value", &Feature::getValue);
+	
+	// rb_mFeature = define_module("Feature");
+	//rb_mFeature.define_module_function("history", &rb_mFeatureHistory);
+	//rb_mFeature.define_module_function("value", &rb_mFeatureValue);
+	//rb_mFeature.define_module_function("calculate", &rb_mFeatureCalculate);
+	//rb_mFeature.define_module_function("to_s", rb_mFeatureToString);
+	
+	Data_Type<LoudnessFeature> rb_cLoudnessFeature = 
+		define_class_under<LoudnessFeature, Feature>(rb_mSirens, "LoudnessFeature")
+		.define_constructor(Constructor<LoudnessFeature>());
+	
+	Data_Type<HarmonicityFeature> rb_cHarmonicityFeature = 
+		define_class_under<HarmonicityFeature, Feature>(rb_mSirens, "HarmonicityFeature")
+		.define_constructor(Constructor<HarmonicityFeature>())
+		.define_method("sampleRate", &HarmonicityFeature::getSampleRate)
+		.define_method("sampleRate=", &HarmonicityFeature::setSampleRate)
+		.define_method("spectrumSize", &HarmonicityFeature::getSpectrumSize)
+		.define_method("spectrumSize=", &HarmonicityFeature::setSpectrumSize)
+		.define_method("searchRegionLength", &HarmonicityFeature::getSearchRegionLength)
+		.define_method("searchRegionLength=", &HarmonicityFeature::setSearchRegionLength)
+		.define_method("absThreshold", &HarmonicityFeature::getAbsThreshold)
+		.define_method("absThreshold=", &HarmonicityFeature::setAbsThreshold)
+		.define_method("threshold", &HarmonicityFeature::getThreshold)
+		.define_method("threshold=", &HarmonicityFeature::setThreshold)
+		.define_method("lpfCoefficient", &HarmonicityFeature::getLPFCoefficient)
+		.define_method("lpfCoefficient=", &HarmonicityFeature::setLPFCoefficient)
+		.define_method("maxPeaks", &HarmonicityFeature::getMaxPeaks)
+		.define_method("maxPeaks=", &HarmonicityFeature::setMaxPeaks);
+		
+	Data_Type<TransientIndexFeature> rb_cTransientIndexFeature = 
+		define_class_under<TransientIndexFeature, Feature>(rb_mSirens, "TransientIndexFeature")
+		.define_constructor(Constructor<TransientIndexFeature>())
+		.define_method("sampleRate", &TransientIndexFeature::getSampleRate)
+		.define_method("sampleRate=", &TransientIndexFeature::setSampleRate)
+		.define_method("spectrumSize", &TransientIndexFeature::getSpectrumSize)
+		.define_method("spectrumSize=", &TransientIndexFeature::setSpectrumSize)
+		.define_method("filters", &TransientIndexFeature::getFilters)
+		.define_method("filters=", &TransientIndexFeature::setFilters)
+		.define_method("mels", &TransientIndexFeature::getMels)
+		.define_method("mels=", &TransientIndexFeature::setMels);
+		
+	Data_Type<SpectralCentroidFeature> rb_cSpectralCentroidFeature = 
+		define_class_under<SpectralCentroidFeature, Feature>(rb_mSirens, "SpectralCentroidFeature")
+		.define_constructor(Constructor<SpectralCentroidFeature>())
+		.define_method("sampleRate", &SpectralCentroidFeature::getSampleRate)
+		.define_method("sampleRate=", &SpectralCentroidFeature::setSampleRate)
+		.define_method("spectrumSize", &SpectralCentroidFeature::getSpectrumSize)
+		.define_method("spectrumSize=", &SpectralCentroidFeature::setSpectrumSize);
+		
+	Data_Type<SpectralSparsityFeature> rb_cSpectralSparsityFeature = 
+		define_class_under<SpectralSparsityFeature, Feature>(rb_mSirens, "SpectralSparsityFeature")
+		.define_constructor(Constructor<SpectralSparsityFeature>());
+			
+	Data_Type<TemporalSparsityFeature> rb_cTemporalSparsityFeature = 
+		define_class_under<TemporalSparsityFeature, Feature>(rb_mSirens, "TemporalSparsityFeature")
+		.define_constructor(Constructor<TemporalSparsityFeature>());
+}

data/sirens-ruby.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sirens-ruby}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brandon Mechtley"]
+  s.date = %q{2009-06-26}
+  s.description = %q{Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds.}
+  s.email = %q{bmechtley+github@gmail.com}
+  s.extensions = ["ext/sirens/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "ext/sirens/extconf.rb",
+     "ext/sirens/sirens.cpp",
+     "sirens-ruby.gemspec",
+     "test/sirens/sirens_test.rb",
+     "test/sirens/test.wav",
+     "test/sirens/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/plant/sirens-ruby}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds.}
+  s.test_files = [
+    "test/sirens/sirens_test.rb",
+     "test/sirens/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/sirens/sirens_test.rb

@@ -0,0 +1,66 @@
+require 'sirens'
+
+s = Sirens::Sound.new
+s.frameLength = 0.04
+s.hopLength = 0.02
+s.open 'test/sirens/test.wav'
+
+print "\n", s
+print "\n\tPath: ", s.path
+print "\n\tSamples: ", s.samples
+print "\n\tSample rate: ", s.sampleRate
+print "\n\tFrame length: ", s.frameLength, "s (", s.samplesPerFrame, " samples)"
+print "\n\tHop length: ", s.hopLength, "s (", s.samplesPerHop, " samples)"
+print "\n\tFFT Size: ", s.fftSize
+print "\n\tSpectrum size: ", s.spectrumSize
+print "\n\n"
+
+loudness = Sirens::LoudnessFeature.new
+temporal_sparsity = Sirens::TemporalSparsityFeature.new
+spectral_sparsity = Sirens::SpectralSparsityFeature.new
+spectral_centroid = Sirens::SpectralCentroidFeature.new
+
+harmonicity = Sirens::HarmonicityFeature.new
+harmonicity.absThreshold = 1
+harmonicity.threshold = 0.1
+harmonicity.searchRegionLength = 5
+harmonicity.maxPeaks = 3
+harmonicity.lpfCoefficient = 0.7
+
+transient_index = Sirens::TransientIndexFeature.new
+transient_index.mels = 15
+transient_index.filters = 30
+
+Array[loudness, temporal_sparsity, spectral_sparsity, spectral_centroid, harmonicity, transient_index].each do |feature|
+  feature.historySize = s.frames
+end
+
+Array[spectral_centroid, harmonicity, transient_index].each do |feature|
+  feature.sampleRate = s.sampleRate
+  feature.spectrumSize = s.spectrumSize
+end
+
+s.sampleFeatures = Array[loudness, temporal_sparsity]
+s.spectralFeatures = Array[spectral_sparsity, spectral_centroid, transient_index, harmonicity]
+
+t1 = Time.new
+
+s.extractFeatures
+
+t2 = Time.new
+
+print 'Elapsed time: ', (t2 - t1), "\n\n"
+
+histories = Array[loudness.history, temporal_sparsity.history, spectral_sparsity.history, 
+  spectral_centroid.history, transient_index.history, harmonicity.history]
+
+file = File.new("test/sirens/features.csv", File::CREAT|File::RDWR, 0644)
+for i in 0..s.frames - 1
+  for j in 0..histories.size - 1
+    file.write(histories[j][i])
+    file.write(',') if i < histories.size - 1
+  end
+  
+  file.write("\n")
+end
+

data/test/sirens/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,64 @@
+--- !ruby/object:Gem::Specification 
+name: plant-sirens-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brandon Mechtley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-26 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds.
+email: bmechtley+github@gmail.com
+executables: []
+
+extensions: 
+- ext/sirens/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- ext/sirens/extconf.rb
+- ext/sirens/sirens.cpp
+- sirens-ruby.gemspec
+- test/sirens/sirens_test.rb
+- test/sirens/test.wav
+- test/sirens/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/plant/sirens-ruby
+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: Ruby gem that implements Sirens, a library for segmentation, indexing, and retrieval of environmental and natural sounds.
+test_files: 
+- test/sirens/sirens_test.rb
+- test/sirens/test_helper.rb