praatrb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bba80e61081fe0185a199334134bd12cb0efc4d5
+  data.tar.gz: 3546c648b01c3bdfeee01dc2cf610766e37b3723
+SHA512:
+  metadata.gz: b83719ea8f9f5635ed2f314d0f6621cfff5b287f03ca4958e6932a1ea387dbb1eccb422862b06efe86b8e08bed56943478002d387a728bb2e49feb1491e11912
+  data.tar.gz: 6a29741d111d46608260172c59398c959bf5396db4e8a1412db2f09dde5e73d2f148c8e6b3ef29d9f0872141988ce2231dfbbb14a53abf1a88fc6517067737a4

data/.autotest

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require "autotest/restart"
+
+# Autotest.add_hook :initialize do |at|
+#   at.testlib = "minitest/unit"
+#
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception "vendor"
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2014-11-04
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,20 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/praat_lex
+lib/praat.rb
+lib/praat_formant.rb
+lib/praat_lexer.rb
+lib/praat_lexer.rex
+lib/praat_lexer.rex.rb
+lib/praat_parser.rb
+lib/praat_pitch.rb
+test/fixtures/tajm.Pitch
+test/test.Pitch
+test/test_praat.rb
+test/test_praat_formant.rb
+test/test_praat_lexer.rb
+test/test_praat_parser.rb
+test/test_praat_pitch.rb

data/README.txt

@@ -0,0 +1,74 @@
+= praat_lex
+
+* http://www.andrewchristophersmith.com/
+
+== DESCRIPTION:
+
+Provides a very malleable Praat file parser
+
+== FEATURES/PROBLEMS:
+
+* Pro: cool idea, doesn't need file specification
+* Con: only sort of works, not really tested
+
+The parser parses the basic grammar of Praat files, creating classes whenever
+it needs them. It results in a tree of Objects and Collections, with a variety
+of attributes that correspond to the grammar it finds in the file. It knows
+nothing about Praat. It also only works with long text files.
+
+== SYNOPSIS:
+
+  require 'praat'
+  my_collection = Praat.parse_file("my_praat_file.Collection")
+  # => #<Praat::Root ... >
+  my_collection.items[0]
+  # => #<Praat::Item ... >
+  # Let's say the first item in the collection was a Pitch object
+  # Collection of frames
+  my_collection.items[0].frames[0].candidates[0].frequency
+  # => 101.2358493290
+
+== REQUIREMENTS:
+
+* oedipux_lex
+
+== INSTALL:
+
+This is experimental. Only git-cloners allowed at this point.
+
+  git clone https://github.com/andrewcsmith/praatrb.git
+  rake install_gem
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 Andrew Christopher Smith
+
+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/Rakefile

@@ -0,0 +1,37 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "hoe"
+require "oedipus_lex"
+
+# Hoe.plugin :compiler
+# Hoe.plugin :email
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :history
+# Hoe.plugin :inline
+Hoe.plugin :minitest
+# Hoe.plugin :perforce
+# Hoe.plugin :racc
+# Hoe.plugin :rcov
+# Hoe.plugin :rdoc
+# Hoe.plugin :rubygems
+# Hoe.plugin :seattlerb
+# Hoe.plugin :travis
+
+Hoe.spec "praatrb" do
+  developer "Andrew Smith", "andrewchristophersmith@gmail.com"
+  dependency "oedipus_lex", "~> 2.4", :developer
+
+  self.group_name = "Andrew Smith" # if part of an organization/group
+
+  license "MIT" # this should match the license in the README
+end
+
+Rake.application.rake_require "oedipus_lex"
+task :lexer => "lib/praat_lexer.rex.rb"
+task :parser => :lexer
+task :test => :parser
+
+file "lib/praat_lexer.rex.rb" => "lib/praat_lexer.rex"
+
+# vim: syntax=ruby

data/bin/praat_lex

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# Accepts one argument: the name of the file to lex and parse. Second optional
+# argument is the encoding of that file.
+
+require 'praat'
+require 'pp'
+
+source_encoding = ARGV[1] || "utf-16"
+
+begin
+  f = File.open(ARGV[0], "rb", {encoding: "#{source_encoding}:utf-8"})
+rescue Encoding::InvalidByteSequenceError => e
+  # If the file reading throws an error, try with the default (utf-8) encoding.
+  if source_encoding != "utf-8"
+    source_encoding = "utf-8"
+    retry
+  else
+    raise e
+  end
+end
+
+s = f.read
+
+begin
+  lexer = Praat::Lexer.new
+  parser = Praat::Parser.new
+
+  lexed = lexer.parse(s)
+  parsed = parser.parse(lexed)
+rescue Praat::Lexer::ScanError => e
+  puts /(.*\n){0,3}/.match(e.message)[0]
+  puts e.backtrace
+  exit
+end
+

data/lib/praat.rb

@@ -0,0 +1,88 @@
+require "praat_lexer.rb"
+require "praat_parser.rb"
+require "praat_pitch.rb"
+require "praat_formant.rb"
+
+module Praat
+  VERSION = "1.0.0"
+
+  # Parses a file given a specified encoding, returning an object containing
+  # nested objects
+  def self.parse_file filename, encoding = 'utf-8'
+    f = File.open(filename, "rb", {encoding: "#{encoding}:utf-8"})
+    Praat::Parser.new.parse(Praat::Lexer.new.parse(f.read))
+  end
+
+  # Turns a hz reading into a midi value.
+  #
+  # hz - The input value in hz
+  # base_hz - The frequency for tuning (i.e., A=440)
+  # base_midi - The midi key that the tuning pitch corresponds to
+  def self.hz_to_midi hz, base_hz = 440.0, base_midi = 69
+    if hz && hz > 0.0
+      (Math.log2(hz.to_f / base_hz) * 12.0) + base_midi
+    else
+      0.0
+    end
+  end
+
+  # Something will be either a collection or an object. Only an object can have
+  # properties.
+  class MetaCollection < Array
+    attr_accessor :parent
+
+    def << object
+      object.parent = self
+      super object
+    end
+
+    def to_s
+      self.inspect << super
+    end
+  end
+
+  class MetaObject
+    attr_accessor :parent
+
+    # Append the object to the collection of names
+    def add_to_collection name, object
+      instance_variable_get("@#{name}s").instance_exec(object) { |o| self << o }
+    end
+
+    # Add the property to the object
+    def add_property name, value
+      # Convert it to snake-case
+      name = sanitize_name name.to_s
+
+      # Add the attr_accessor if it doesn't exist
+      unless self.respond_to? "#{name}"
+        self.class.class_exec(name) do |n|
+          attr_accessor n.to_sym
+        end
+      end
+
+      if value.respond_to? :parent=
+        value.parent = self
+      end
+
+      # Set the attribute to the value
+      self.send("#{name}=", value)
+    end
+
+    def to_s
+      "#{self.inspect}" 
+    end
+
+    private
+
+    def sanitize_name name
+      if name == "class"
+        name = "klass"
+      end
+      name.downcase.sub(' ', '_')
+    end
+  end
+  
+  class Root < MetaObject; end
+end
+

data/lib/praat_formant.rb

@@ -0,0 +1,19 @@
+module Praat
+  def self.dominant_frame item
+    dominant_frame = item.frames.max {|a, b|
+      a.intensity <=> b.intensity
+    }
+    item.add_property :dominant_frame, dominant_frame
+    item
+  end
+
+  class MetaObject; end
+  class Item < MetaObject
+    def map_formant_frequencies
+      self.framess.map {|frame|
+        frame.formants.map(&:frequency)
+      }
+    end
+  end
+end
+

data/lib/praat_lexer.rb

@@ -0,0 +1,40 @@
+module Praat; end
+
+require "praat_lexer.rex.rb"
+
+class Praat::Lexer
+  def do_parse 
+    output = [] 
+    while token = next_token do
+      type, *vals = token
+      output << send("lex_#{type}", *vals)
+    end
+    output
+  end
+
+  def lex_float_property property, value
+    [:property, property.chomp, value.to_f]
+  end
+
+  def lex_integer_property property, value
+    [:property, property.chomp, value.to_i]
+  end
+
+  def lex_string_property property, value
+    [:property, property.chomp, value.chomp]
+  end
+
+  def lex_collection collection
+    [:collection, collection.chomp]
+  end
+
+  def lex_object object, index
+    [:object, object.chomp, index.to_i]
+  end
+
+  def lex_indent spaces
+    indents = spaces.length / 4
+    [:indent, indents]
+  end
+end
+

data/lib/praat_lexer.rex

@@ -0,0 +1,24 @@
+module Praat; end
+
+class Praat::Lexer
+macros
+  INTEGER /\d+/
+  FLOAT /\d+\.\d+(?:e-\d\d)?/ # also captures scientific notation
+  NUMBER /#{FLOAT}|#{INTEGER}/
+  LETTER /[\w\u0250-\u02AF\u00E6\u00F0\u03B8\u014B]/ # includes IPA symbols
+  WORD /#{LETTER}+(?: #{LETTER}*)?/ # words may optionally have a space
+rules
+  # Parse various tokens
+  /(#{WORD}) = (#{FLOAT})/    { [:float_property, *matches] }
+  /(#{WORD}) = (#{INTEGER})/  { [:integer_property, *matches] }
+  /(#{WORD}) = "(#{WORD})"/   { [:string_property, *matches] }
+  /(#{WORD}) \[\]:/           { [:collection, *matches] }
+  /(#{WORD}) \[(#{INTEGER})\]:/ { [:object, *matches] }
+  /( {4}+)/                  { [:indent, *matches] }
+
+  # Trailing whitespace and empty lines
+  /\s*\n/
+end
+
+# vim: filetype=ruby
+

data/lib/praat_lexer.rex.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.4.0.
+# Source: lib/praat_lexer.rex
+#++
+
+module Praat; end
+
+class Praat::Lexer
+  require 'strscan'
+
+  INTEGER = /\d+/
+  FLOAT   = /\d+\.\d+(?:e-\d\d)?/
+  NUMBER  = /#{FLOAT}|#{INTEGER}/
+  LETTER  = /[\w\u0250-\u02AF\u00E6\u00F0\u03B8\u014B]/
+  WORD    = /#{LETTER}+(?: #{LETTER}*)?/
+
+  class ScanError < StandardError ; end
+
+  attr_accessor :filename
+  attr_accessor :ss
+  attr_accessor :state
+
+  alias :match :ss
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  def action
+    yield
+  end
+
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      token =
+        case state
+        when nil then
+          case
+          when text = ss.scan(/(#{WORD}) = (#{FLOAT})/) then
+            action { [:float_property, *matches] }
+          when text = ss.scan(/(#{WORD}) = (#{INTEGER})/) then
+            action { [:integer_property, *matches] }
+          when text = ss.scan(/(#{WORD}) = "(#{WORD})"/) then
+            action { [:string_property, *matches] }
+          when text = ss.scan(/(#{WORD}) \[\]:/) then
+            action { [:collection, *matches] }
+          when text = ss.scan(/(#{WORD}) \[(#{INTEGER})\]:/) then
+            action { [:object, *matches] }
+          when text = ss.scan(/( {4}+)/) then
+            action { [:indent, *matches] }
+          when text = ss.scan(/\s*\n/) then
+            # do nothing
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}): '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise "bad lexical result: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+end # class
+
+  # vim: filetype=ruby

data/lib/praat_parser.rb

@@ -0,0 +1,56 @@
+module Praat; end
+
+class Praat::Parser
+  def parse input
+    output = Praat::Root.new
+    @current_node = output
+    @current_indent = 0
+    input.each do |item|
+      case item.shift
+      when :indent
+        process_indent item
+      when :collection
+        @current_node.add_property "#{item.first}s", create_collection(item.first)
+        @current_node = @current_node.send("#{item.first}s")
+      when :object
+        @current_node << create_object(item.first)
+        @current_node.last.parent = @current_node
+        @current_node = @current_node.last
+      when :property
+        @current_node.add_property(*item)
+      end
+    end
+    output
+  end
+
+  private
+
+  def process_indent item
+    indent = item.first
+    # If the new indent is a backstep
+    if indent < @current_indent
+      # Go back
+      (@current_indent - indent).times do
+        @current_node = @current_node.parent
+      end
+    end
+    @current_indent = item.first
+  end
+
+  def create_collection klass
+    klass = klass.capitalize << "s"
+    unless Object.const_defined? "Praat::#{klass}"
+      Praat.class_eval "class #{klass} < Praat::MetaCollection; end"
+    end
+    (Praat.const_get "#{klass}").new
+  end
+
+  def create_object klass
+    klass = klass.capitalize
+    unless Object.const_defined? "Praat::#{klass}"
+      Praat.class_eval "class #{klass} < Praat::MetaObject; end"
+    end
+    (Praat.const_get "#{klass}").new
+  end
+end
+

data/lib/praat_pitch.rb

@@ -0,0 +1,20 @@
+module Praat
+  def self.find_dominant_pitch item
+    item.frames.map! do |frame|
+      top = frame.candidates.max do |a, b|
+        a.strength <=> b.strength
+      end
+
+      frame.add_property "freq", top.frequency
+     
+      # Filter out the unvoiced candidates 
+      if frame.freq > item.ceiling
+        frame.freq = nil
+      end
+
+      frame
+    end
+    item
+  end
+end
+