plant-sirens 0.0.4

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,51 @@
+# 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 these two libraries:
+
+1. [FFTW](http://www.fftw.org/download.html)
+2. [Sirens](http://github.com/plant/sirens)
+
+Additionally, sirens-ruby has the following gem dependencies, which RubyGems should take care of:
+
+1. [rake-compiler](http://rubyforge.org/projects/rake-compiler/)
+2. [jeweler](http://github.com/technicalpickles/jeweler/)
+2. [rice](http://github.com/cout/rice/) 
+
+*Rice Note:* I've had some problems with installing the Rice 1.1.0 gem. Try 1.0.2 if it doesn't work. On OSX, neither seems to work, so you may want to look at [this workaround](http://rubyforge.org/tracker/index.php?func=detail&aid=19828&group_id=4163&atid=16066). Note that you will have to remove `-arch ppc` (or `-arch i386`) from all makefiles, i.e. Makefile, rice/Makefile, ruby/Makefile, and test/Makefile.
+
+## Installation
+To install Soundwalk, type:
+
+	gem sources -a http://gems.github.com
+	sudo gem install plant-sirens-ruby
+
+*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 Sirens don't build universal binaries by default. You can ignore this warning, as it won't affect you unless you're trying to copy sirens.so directly between machines of different architectures. 
+
+## 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) from a sound file:
+	
+	require 'sirens'
+	include Sirens
+	
+	s = Sound.new
+  	s.frameLength = 0.04
+  	s.hopLength = 0.02
+  	
+	s.open('sound.wav')
+	
+	loudness = Loudness.new
+	loudness.historySize = s.frames
+	
+	s.sampleFeatures = [loudness]
+	s.extractFeatures
+	
+	puts loudness.history
+
+More examples can be found in the /examples folder. Detailed documentation is on the [Wiki](http://wiki.github.com/plant/sirens-ruby).
+
+# Copyright
+Copyright (c) 2009 Brandon Mechtley. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  spec = Jeweler::Tasks.new do |gem|
+    gem.files.include %w(ext/sirens/extconf.rb ext/sirens/sirens.cpp)
+    gem.name = "sirens"
+    gem.add_dependency('rice', '>= 1.0.2')
+    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
+
+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.4

data/examples/three_features.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'sirens'
+include Sirens
+
+s = Sound.new
+s.frameLength = 0.04
+s.hopLength = 0.02
+s.open('sound.wav')
+l = Loudness.new
+ss = SpectralSparsity.new
+ts = TemporalSparsity.new
+ts.windowSize = 50
+
+[l, ss, ts].each do |f|
+  f.historySize = s.frames
+end
+
+s.sampleFeatures = [l, ts]
+s.spectralFeatures = [ss]
+
+s.extractFeatures
+
+[l, ss, ts].each do |f|
+	f.history.each {|value| print value, ','}
+	print "\n"
+end

data/ext/sirens/extconf.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'mkmf'
+
+# Upon requiring mkmf-rice, Rice makes sure -lrice can be found
+# but it won't be found if it's not in the default library search
+# path. require 'mkmf' above just initializes the environment
+# variables for us.
+
+$LDFLAGS << " #{ENV['LDFLAGS']}"
+
+require 'mkmf-rice'
+
+$CPPFLAGS << " #{ENV['CPPFLAGS']}"
+$LDFLAGS << " #{ENV['LDFLAGS']}"
+$CFLAGS << " #{ENV['CFLAGS']} -D__OS_MACOSX__"
+
+have_library('sirens')
+have_library('fftw3')
+
+create_makefile('sirens')

data/ext/sirens/sirens.cpp

@@ -0,0 +1,160 @@
+#include "rice/Class.hpp"
+#include "rice/Array.hpp"
+#include "rice/String.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+using namespace Rice;
+
+#include "sirens/Sound.h"
+#include "sirens/CircularArray.h"
+#include "sirens/features/Loudness.h"
+#include "sirens/features/Harmonicity.h"
+#include "sirens/features/TransientIndex.h"
+#include "sirens/features/SpectralCentroid.h"
+#include "sirens/features/SpectralSparsity.h"
+#include "sirens/features/TemporalSparsity.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<Loudness> rb_cLoudness = 
+		define_class_under<Loudness, Feature>(rb_mSirens, "Loudness")
+		.define_constructor(Constructor<Loudness>());
+	
+	Data_Type<Harmonicity> rb_cHarmonicity = 
+		define_class_under<Harmonicity, Feature>(rb_mSirens, "Harmonicity")
+		.define_constructor(Constructor<Harmonicity>())
+		.define_method("sampleRate", &Harmonicity::getSampleRate)
+		.define_method("sampleRate=", &Harmonicity::setSampleRate)
+		.define_method("spectrumSize", &Harmonicity::getSpectrumSize)
+		.define_method("spectrumSize=", &Harmonicity::setSpectrumSize)
+		.define_method("searchRegionLength", &Harmonicity::getSearchRegionLength)
+		.define_method("searchRegionLength=", &Harmonicity::setSearchRegionLength)
+		.define_method("absThreshold", &Harmonicity::getAbsThreshold)
+		.define_method("absThreshold=", &Harmonicity::setAbsThreshold)
+		.define_method("threshold", &Harmonicity::getThreshold)
+		.define_method("threshold=", &Harmonicity::setThreshold)
+		.define_method("lpfCoefficient", &Harmonicity::getLPFCoefficient)
+		.define_method("lpfCoefficient=", &Harmonicity::setLPFCoefficient)
+		.define_method("maxPeaks", &Harmonicity::getMaxPeaks)
+		.define_method("maxPeaks=", &Harmonicity::setMaxPeaks);
+		
+	Data_Type<TransientIndex> rb_cTransientIndex = 
+		define_class_under<TransientIndex, Feature>(rb_mSirens, "TransientIndex")
+		.define_constructor(Constructor<TransientIndex>())
+		.define_method("sampleRate", &TransientIndex::getSampleRate)
+		.define_method("sampleRate=", &TransientIndex::setSampleRate)
+		.define_method("spectrumSize", &TransientIndex::getSpectrumSize)
+		.define_method("spectrumSize=", &TransientIndex::setSpectrumSize)
+		.define_method("filters", &TransientIndex::getFilters)
+		.define_method("filters=", &TransientIndex::setFilters)
+		.define_method("mels", &TransientIndex::getMels)
+		.define_method("mels=", &TransientIndex::setMels);
+		
+	Data_Type<SpectralCentroid> rb_cSpectralCentroid = 
+		define_class_under<SpectralCentroid, Feature>(rb_mSirens, "SpectralCentroid")
+		.define_constructor(Constructor<SpectralCentroid>())
+		.define_method("sampleRate", &SpectralCentroid::getSampleRate)
+		.define_method("sampleRate=", &SpectralCentroid::setSampleRate)
+		.define_method("spectrumSize", &SpectralCentroid::getSpectrumSize)
+		.define_method("spectrumSize=", &SpectralCentroid::setSpectrumSize);
+		
+	Data_Type<SpectralSparsity> rb_cSpectralSparsity = 
+		define_class_under<SpectralSparsity, Feature>(rb_mSirens, "SpectralSparsity")
+		.define_constructor(Constructor<SpectralSparsity>());
+			
+	Data_Type<TemporalSparsity> rb_cTemporalSparsity = 
+		define_class_under<TemporalSparsity, Feature>(rb_mSirens, "TemporalSparsity")
+		.define_constructor(Constructor<TemporalSparsity>())
+		.define_method("windowSize", &TemporalSparsity::getWindowSize)
+		.define_method("windowSize=", &TemporalSparsity::setWindowSize);
+}

data/test/sirens/sirens_test.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+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,73 @@
+--- !ruby/object:Gem::Specification 
+name: plant-sirens
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Brandon Mechtley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rice
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+    version: 
+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
+- 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
+- examples/three_features.rb