stft_spectrogram 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99877f8a2002a628db8806a2c1fb849697db4a33
+  data.tar.gz: d4e8f28a846a6bdad15df267554a62b27d5e355c
+SHA512:
+  metadata.gz: 7c80c44e7c8a2f80505822f4995ec41e847369382b4bf1dafa087b5d28ad6e207f1b131fa48e554f23217f7658a2e6dbed694bac8dc2d3f952ec20a29272e99f
+  data.tar.gz: 4f6ddcc453bf7f1f984941a016b45d553a1ffef472c90f8ac94965ffeea18f5240aa392686152c4f565395e66cffc0a9af3bf11c917aef647baa6f81566b7036

data/bin/stft_spectrogram

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'stft_spectrogram'
+STFTSpectrogram.start

data/lib/audio/audio_file.rb

@@ -0,0 +1,79 @@
+require 'wavefile'
+
+module STFTSpectrogram
+  # Represents wave file
+  class AudioFile
+    include WaveFile
+
+    attr_reader :window_overlap
+    attr_reader :window_size
+
+    SAMPLE_RATE = 441_00
+
+    def initialize(path, wsize = 1, woverlap = 0)
+      unless File.file?(path)
+        raise IOError, "File '" + path + "' does not exist!"
+      end
+      @samples = []
+      self.window_size = wsize
+      self.window_overlap = woverlap
+      @window_overlap = @window_size / 2 if @window_size <= @window_overlap
+      @window_pos = 0
+      read_data(path)
+    end
+
+    def read_data(path)
+      format = Format.new(:mono, :float, SAMPLE_RATE)
+      Reader.new(path, format).each_buffer do |buffer|
+        buffer.samples.each { |s| @samples.push(s) }
+      end
+    end
+
+    # Nearest power of 2 to num
+    def nearest_pow2(num)
+      return 0 if num <= 0
+      2**Math.log2(num).round
+    end
+
+    def window_overlap=(overlap)
+      @window_overlap = nearest_pow2(overlap * (SAMPLE_RATE / 1000))
+    end
+
+    def window_size=(size)
+      @window_size = nearest_pow2(size * (SAMPLE_RATE / 1000))
+    end
+
+    # Gets window_size of data from audio samples
+    # and moves the window pointer
+    def next_window
+      return [] if end?
+
+      slice = @samples[@window_pos, @window_size]
+      slice.fill(0, slice.length..@window_size - 1)
+      @window_pos += @window_size - @window_overlap
+
+      slice
+    end
+
+    def self.sample_rate
+      SAMPLE_RATE
+    end
+
+    # Resets the window pointer
+    def reset
+      @window_pos = 0
+    end
+
+    # Gets the time corresponding to the window pointers location
+    def current_time
+      (@window_pos + @window_size / 2) / (SAMPLE_RATE / 1000)
+    end
+
+    # Checks if the window pointer is at the end of the file
+    def end?
+      @window_pos + @window_size >= @samples.length
+    end
+
+    private :read_data, :nearest_pow2
+  end
+end

data/lib/gui/gui.rb

@@ -0,0 +1,265 @@
+require 'fox16'
+require_relative '../stft/spectrogram.rb'
+require_relative '../plot/plot.rb'
+require_relative '../audio/audio_file.rb'
+
+include Fox
+
+# Main module
+module STFTSpectrogram
+  # User interface
+  class GUI < FXMainWindow
+    PLOT_TYPE_SPECTROGRAM = 1
+    PLOT_TYPE_TOP_MAGNITUDES = 2
+    MIN_WINDOW_WIDTH = 960
+    MIN_WINDOW_HEIGHT = 960
+
+    def initialize(app)
+      super(app, 'STFT Spectrogram generator', width: 1280, height: 720,
+                                               opts: DECOR_ALL &
+                                                 ~DECOR_SHRINKABLE)
+
+      @plot = Plot.new
+
+      @audio = nil
+      @spectrogram = nil
+
+      vframe1 = FXVerticalFrame.new(self, width: 1280, opts: LAYOUT_FILL)
+      hframe1 = FXHorizontalFrame.new(vframe1, opts: LAYOUT_FILL | FRAME_SUNKEN)
+      @img_spectrum = FXImageView.new(hframe1, opts: LAYOUT_FILL)
+
+      @current_spec_img = nil
+
+      hframe2 = FXHorizontalFrame.new(vframe1)
+
+      vframe_window = FXVerticalFrame.new(hframe2, opts: LAYOUT_FILL)
+      hframe_window_size = FXHorizontalFrame.new(vframe_window,
+                                                 opts: LAYOUT_RIGHT)
+      hframe_window_overlap = FXHorizontalFrame.new(vframe_window,
+                                                    opts: LAYOUT_RIGHT)
+      FXLabel.new(hframe_window_size, 'Window size:')
+      @spin_window_size = FXSpinner.new(hframe_window_size, 10)
+      @spin_window_size.range = 1..(2**31 - 1)
+      @spin_window_size.value = 1
+      FXLabel.new(hframe_window_size, 'ms')
+      FXLabel.new(hframe_window_overlap, 'Window overlap:')
+      @spin_window_overlap = FXSpinner.new(hframe_window_overlap, 10)
+      @spin_window_overlap.range = 0..(2**31 - 1)
+      FXLabel.new(hframe_window_overlap, 'ms')
+
+      FXVerticalSeparator.new(hframe2)
+
+      vframe_freq = FXVerticalFrame.new(hframe2, opts: LAYOUT_FILL)
+      hframe_freq_low = FXHorizontalFrame.new(vframe_freq, opts: LAYOUT_RIGHT)
+      hframe_freq_high = FXHorizontalFrame.new(vframe_freq, opts: LAYOUT_RIGHT)
+      FXLabel.new(hframe_freq_low, 'Low pass:')
+      @spin_freq_low = FXSpinner.new(hframe_freq_low, 10)
+      @spin_freq_low.range = 0..(2**31 - 1)
+      FXLabel.new(hframe_freq_low, 'Hz')
+      FXLabel.new(hframe_freq_high, 'High pass:')
+      @spin_freq_high = FXSpinner.new(hframe_freq_high, 10)
+      @spin_freq_high.range = 0..(2**31 - 1)
+      FXLabel.new(hframe_freq_high, 'Hz')
+
+      FXVerticalSeparator.new(hframe2)
+
+      vframe_wav = FXVerticalFrame.new(hframe2, opts: LAYOUT_FILL)
+      hframe_wav_txt = FXHorizontalFrame.new(vframe_wav, opts: LAYOUT_RIGHT)
+      hframe_wav_btn = FXHorizontalFrame.new(vframe_wav, opts: LAYOUT_RIGHT)
+      FXLabel.new(hframe_wav_txt, 'Loaded wave file:')
+      @txt_wav_file = FXTextField.new(hframe_wav_txt, 60,
+                                      opts: TEXTFIELD_READONLY)
+      btn_wav_open = FXButton.new(hframe_wav_btn, 'Select WAV file')
+      btn_wav_open.connect(SEL_COMMAND) { open_wav_file }
+
+      FXVerticalSeparator.new(hframe2)
+
+      vframe_plot = FXVerticalFrame.new(hframe2, opts: LAYOUT_FILL)
+      hframe_plot_type = FXHorizontalFrame.new(vframe_plot, opts: LAYOUT_RIGHT)
+      hframe_gen_plot = FXHorizontalFrame.new(vframe_plot, opts: LAYOUT_RIGHT)
+
+      @combo_plot_type = FXComboBox.new(hframe_plot_type, 25,
+                                        opts: COMBOBOX_STATIC)
+      @combo_plot_type.appendItem('Spectrogram', PLOT_TYPE_SPECTROGRAM)
+      @combo_plot_type.appendItem('Most significant frequencies only',
+                                  PLOT_TYPE_TOP_MAGNITUDES)
+
+      btn_plot = FXButton.new(hframe_gen_plot, 'Generate plot')
+      btn_plot.connect(SEL_COMMAND) { on_btnplot_pressed }
+
+      FXVerticalSeparator.new(hframe2)
+
+      hframe_save_img = FXHorizontalFrame.new(hframe2, opts: LAYOUT_RIGHT)
+      btn_save_img = FXButton.new(hframe_save_img, 'Save graph')
+      btn_save_img.connect(SEL_COMMAND) { on_save_graph }
+
+      @spin_window_size.connect(SEL_COMMAND) { on_window_changed }
+      @spin_window_overlap.connect(SEL_COMMAND) { on_window_changed }
+    end
+
+    def create
+      super
+      show(PLACEMENT_SCREEN)
+    end
+
+    private
+
+    def open_wav_file
+      dialog = FXFileDialog.new(self, 'Open WAV File')
+      dialog.patternList = ['WAV Files (*.wav)']
+      dialog.selectMode = SELECTFILE_EXISTING
+      return if dialog.execute.zero?
+      @txt_wav_file.text = ''
+      @spectrogram = nil
+      @audio = load_data(dialog.filename)
+      @txt_wav_file.text = dialog.filename unless @audio.nil?
+    end
+
+    def save_graph(path)
+      getApp.beginWaitCursor do
+        FXFileStream.open(path, FXStreamSave) do |stream|
+          @current_spec_img.savePixels(stream)
+        end
+      end
+    end
+
+    def on_save_graph
+      if @current_spec_img.nil?
+        FXMessageBox.error(self, MBOX_OK, 'No image!',
+                           'Generate the graph first!')
+        return
+      end
+      dialog = FXFileDialog.new(self, 'Save Graph')
+      dialog.patternList = ['PNG Files (*.png)']
+      dialog.filename = '*.png'
+      unless dialog.execute.zero?
+        if File.exist? dialog.filename
+          overwrite = FXMessageBox.question(self, MBOX_YES_NO,
+                                            'File exists!',
+                                            'Overwrite file?')
+          return 1 if overwrite == MBOX_CLICKED_NO
+        end
+        save_graph(dialog.filename)
+      end
+      1
+    end
+
+    def load_data(path)
+      audio = nil
+      begin
+        audio = AudioFile.new(path)
+      rescue IOError => e
+        FXMessageBox.error(self, MBOX_OK, 'Non-existing file!', e.message)
+        return nil
+      rescue WaveFile::FormatError => e
+        FXMessageBox.error(self, MBOX_OK, 'Bad format!', e.message)
+        return nil
+      end
+      audio
+    end
+
+    def create_spectrogram
+      return nil if @audio.nil?
+      return @spectrogram unless @spectrogram.nil?
+      spectrogram = nil
+      begin
+        spectrogram = Spectrogram.new(@audio, @spin_window_size.value,
+                                      @spin_window_overlap.value)
+      rescue ArgumentError => e
+        FXMessageBox.error(self, MBOX_OK, 'Bad arguments!', e.message)
+        return nil
+      end
+      spectrogram
+    end
+
+    def on_window_changed
+      @spectrogram = nil
+    end
+
+    def on_btnplot_pressed
+      @spectrogram = create_spectrogram
+      return if @spectrogram.nil?
+      @spectrogram.transform! unless @spectrogram.transformed?
+      @spectrogram.filter(@spin_freq_low.value, @spin_freq_high.value)
+
+      index = @combo_plot_type.currentItem
+      return if index < 0
+
+      type = @combo_plot_type.getItemData(index)
+
+      if type == PLOT_TYPE_SPECTROGRAM
+        plot_spectrogram
+      elsif type == PLOT_TYPE_TOP_MAGNITUDES
+        plot_top_freqs
+      end
+    end
+
+    def load_generated_image(path)
+      @current_spec_img = FXPNGImage.new(getApp, nil, IMAGE_KEEP |
+                                           IMAGE_OWNED | IMAGE_SHMP |
+                                           IMAGE_SHMI)
+      getApp.beginWaitCursor do
+        FXFileStream.open(path, FXStreamLoad) do |stream|
+          @current_spec_img.loadPixels(stream)
+        end
+        @current_spec_img.create
+        @img_spectrum.image = @current_spec_img
+      end
+    end
+
+    def no_data?(data)
+      if data.empty?
+        FXMessageBox.error(self, MBOX_OK, 'No data!',
+                           'Selected slice contains no data!')
+        return true
+      end
+      false
+    end
+
+    def plot_top_freqs
+      freqs = @spectrogram.freqs
+      return if no_data? freqs
+      y = @spectrogram.windows.map { |w| w.strongest_freq[0] / 1000.0 }
+      x = @spectrogram.windows.map(&:time)
+      @plot.xtics = 'auto'
+      @plot.ytics = 'auto'
+      @plot.plot(x, y, @img_spectrum.width, @img_spectrum.height)
+      load_generated_image(@plot.imgfile.path)
+    end
+
+    def plot_spectrogram
+      freqs = @spectrogram.freqs
+      return if no_data? freqs
+      data = @spectrogram.windows.map { |w| w.spectrum.values }
+
+      x = @spectrogram.windows.map { |w| w.time.to_i }.uniq
+      len = data.length / x.length
+      xmap = x.map.with_index do |t, i|
+        '"' + t.to_s + '" ' + (i * len).to_s
+      end
+      len = x.length / [x.length, 15].min
+      xmap = (len - 1).step(xmap.size - 1, len).map { |i| xmap[i] }
+      data = data.transpose
+      len = data.length / freqs.length
+      ymap = freqs.map.with_index do |f, i|
+        '"' + (f / 1000.0).to_s + '" ' + (i * len).to_s
+      end
+      len = freqs.length / [freqs.length, 20].min
+      ymap = (len - 1).step(ymap.size - 1, len).map { |i| ymap[i] }
+
+      @plot.xtics = '(' + xmap.join(', ') + ')'
+      @plot.ytics = '(' + ymap.join(', ') + ')'
+      @plot.plot_matrix(data, @img_spectrum.width, @img_spectrum.height)
+
+      load_generated_image(@plot.imgfile.path)
+    end
+  end
+
+  def self.start
+    FXApp.new do |app|
+      STFTSpectrogram::GUI.new(app)
+      app.create
+      app.run
+    end
+  end
+end

data/lib/plot/plot.rb

@@ -0,0 +1,84 @@
+require 'numo/gnuplot'
+require 'tempfile'
+
+module STFTSpectrogram
+  # Creates plots using gnuplot
+  class Plot
+    TEMP_SPECTR_IMG_FILE = 'spec'.freeze
+    TEMP_SPECTR_DAT_FILE = 'spec.dat'.freeze
+
+    attr_reader :imgfile
+
+    def initialize
+      @imgfile = Tempfile.new([TEMP_SPECTR_IMG_FILE, '.png'])
+      @imgfile.close
+      set_gnuplot_defaults
+    end
+
+    def set_gnuplot_defaults
+      Numo.gnuplot do
+        set title: ''
+        set palette: 'rgb 34,35,36'
+        set cblabel: 'Magnitude'
+        set xtics: 'auto'
+        set ytics: 'auto'
+        set xlabel: 'Time (s)'
+        set ylabel: 'Frequency (kHz)'
+      end
+    end
+
+    # Sets x axis tics
+    def xtics=(str)
+      Numo.gnuplot { set xtics: str }
+    end
+
+    # Sets y axis tics
+    def ytics=(str)
+      Numo.gnuplot { set ytics: str }
+    end
+
+    def write_temp_data(data)
+      datafile = Tempfile.new(TEMP_SPECTR_DAT_FILE)
+      datafile.write(data.map { |row| row.join(' ') }.join("\n"))
+      datafile.close
+      datafile
+    end
+
+    def build_term_str(w, h, fnt_size)
+      'png font arial ' + fnt_size.to_s + ' size ' + w.to_s + ',' + h.to_s
+    end
+
+    # Plots data in a matrix format using a temporary file
+    # Data are plotted to 2D with their magnitude being differentiated
+    # by color gradient
+    def plot_matrix(data, w = 1920, h = 1080, fnt_size = 12)
+      tmpfile = write_temp_data(data)
+      outfile = @imgfile.path
+      termstr = build_term_str(w, h, fnt_size)
+      Numo.gnuplot do
+        set term: termstr
+        set output: outfile
+        plot "'" + tmpfile.path + "'", :matrix, w: 'image', t: ''
+        unset :output
+      end
+      tmpfile.unlink
+    end
+
+    # Plots data contained int x and y parameters
+    def plot(x, y, w = 1920, h = 1080, fnt_size = 12)
+      outfile = @imgfile.path
+      termstr = build_term_str(w, h, fnt_size)
+      Numo.gnuplot do
+        set term: termstr
+        set output: outfile
+        set autoscale: 'xfix'
+        set autoscale: 'yfix'
+        set autoscale: 'cbfix'
+        plot x, y, w: 'lines', t: '', lc_rgb: 'red'
+        unset :output
+      end
+    end
+
+    private :set_gnuplot_defaults
+  end
+end

data/lib/stft/fft.rb

@@ -0,0 +1,82 @@
+
+module STFTSpectrogram
+  # Computes FFT
+  module FFT
+    # Implementation of the Fast Fourier Transform algorithm
+    class FFTComputation
+      # Performs FFT on data
+      # Expects data in complex format - even indexes contain real numbers
+      # odd indexes contain imaginary numbers
+      def perform(data)
+        unless pow2? data.length
+          raise ArgumentError, 'Data array for FFT has to be power of 2 long'
+        end
+        data = reindex(data)
+        danielson_lanzcos(data)
+      end
+
+      # Reindexing part of the algorithm
+      # Data are shifted in preparation
+      # for the Danielson-Lanczos
+      def reindex(data)
+        j = 1
+        (1..data.length - 1).step(2) do |i|
+          data[j], data[i] = data[i], data[j] if j > i
+          data[j - 1], data[i - 1] = data[i - 1], data[j - 1] if j > i
+          m = data.length / 2
+          while m >= 2 && j > m
+            j -= m
+            m /= 2
+          end
+          j += m
+        end
+        data
+      end
+
+      # The Danielson-Lanczos part of the algorithm
+      def danielson_lanzcos(data)
+        mmax = 2
+        n = data.length
+        while n > mmax
+
+          istep = mmax * 2
+          theta = -(2.0 * Math::PI / mmax.to_f)
+          wtemp = Math.sin(theta / 2.0)
+          wpr = -2.0 * wtemp * wtemp
+          wpi = Math.sin(theta)
+          wr = 1.0
+          wi = 0.0
+          (1..mmax - 1).step(2) do |m|
+            (m..n).step(istep) do |i|
+              j = i + mmax
+              tempr = wr * data[j - 1] - wi * data[j]
+              tempi = wr * data[j] + wi * data[j - 1]
+              data[j - 1] = data[i - 1] - tempr
+              data[j] = data[i] - tempi
+              data[i - 1] += tempr
+              data[i] += tempi
+            end
+            wtemp = wr
+            wr += wr * wpr - wi * wpi
+            wi += wi * wpr + wtemp * wpi
+          end
+          mmax = istep
+        end
+        data
+      end
+
+      # Returns true is num is a power of 2
+      def pow2?(num)
+        num.to_s(2).count('1') == 1
+      end
+
+      private :reindex, :danielson_lanzcos, :pow2?
+    end
+
+    # Performs FFT on data
+    def self.do_fft(data)
+      fft = FFTComputation.new
+      fft.perform(data)
+    end
+  end
+end

data/lib/stft/spectrogram.rb

@@ -0,0 +1,61 @@
+require_relative 'stft_slice.rb'
+require_relative '../audio/audio_file.rb'
+
+module STFTSpectrogram
+  # Represents time-frequency spectrogram
+  class Spectrogram
+    attr_reader :windows
+
+    def initialize(audio, window_size, window_overlap)
+      if window_size <= window_overlap
+        raise ArgumentError, 'Window size cannot be <= window overlap!'
+      end
+
+      @windows = []
+      @transformed = false
+      audio.window_size = window_size
+      audio.window_overlap = window_overlap
+      split_to_windows(audio)
+      audio.reset
+    end
+
+    def split_to_windows(audio)
+      until audio.end?
+        @windows.push(STFTSlice.new(audio.next_window, audio.current_time))
+      end
+    end
+
+    # Performs FFT on all timed data windows
+    def transform!
+      @windows.each(&:do_fft!)
+      @transformed = true
+    end
+
+    # Gets the highest frequency
+    def max_freq
+      return 0 unless transformed?
+      @windows[0].max_freq
+    end
+
+    # Returns an array with all frequencies
+    def freqs
+      return [] unless transformed?
+      @windows[0].freqs
+    end
+
+    # Sets low and high frequency filters
+    def filter(low, high)
+      @windows.each do |w|
+        w.low = low
+        w.high = high
+      end
+    end
+
+    # Returns true if FFT was already performed
+    def transformed?
+      @transformed
+    end
+
+    private :split_to_windows
+  end
+end

data/lib/stft/stft_slice.rb

@@ -0,0 +1,68 @@
+require_relative 'fft.rb'
+require_relative '../audio/audio_file.rb'
+
+module STFTSpectrogram
+  # Represents a data slic. Performs FFT
+  class STFTSlice
+    attr_reader :data
+    attr_reader :time
+
+    attr_writer :low
+    attr_writer :high
+
+    def initialize(data, time = 0)
+      @spectrum = {}
+      @data = data.product([0]).flatten
+      @time = time / 1000.0 # ms to seconds
+      @low = 0
+      @high = 0
+    end
+
+    # Performs FFT on this data window
+    def do_fft!
+      FFT.do_fft(@data)
+      @data, = @data.drop(2).each_slice((@data.size / 2.0).round).to_a
+      create_spectrum!
+    end
+
+    # Creates a spectrogram from the transformed data - frequencies
+    # with their magnitudes
+    # Spectrogram is saved in a Hashmap, with frequency as the key
+    def create_spectrum!
+      # l, _r = @data.drop(2).each_slice((@data.size / 2.0).round).to_a
+      @data.each_slice(2).with_index do |(real, img), i|
+        freq = (i * (AudioFile.sample_rate / @data.length))
+        magnitude = Math.sqrt(real * real + img * img)
+        @spectrum[freq] = magnitude
+      end
+    end
+
+    # Returns strongest frequency with its magnitude
+    def strongest_freq
+      spectrum.max_by { |_k, v| v }
+    end
+
+    # Returns highest frequency in this time window
+    def max_freq
+      freqs.max
+    end
+
+    # Returns frequencies
+    def freqs
+      ret = @spectrum.keys
+      ret.select! { |f| f >= @low } unless @low.zero?
+      ret.select! { |f| f <= @high } unless @high.zero?
+      ret
+    end
+
+    # Returns frequencies with their magnitudes in this time window
+    def spectrum
+      ret = @spectrum.dup
+      ret.select! { |f, _m| f >= @low } unless @low.zero?
+      ret.select! { |f, _m| f <= @high } unless @high.zero?
+      ret
+    end
+
+    private :create_spectrum!
+  end
+end

data/lib/stft_spectrogram.rb

@@ -0,0 +1,10 @@
+require_relative './audio/audio_file.rb'
+require_relative './stft/fft.rb'
+require_relative './stft/spectrogram.rb'
+require_relative './stft/stft_slice.rb'
+require_relative './gui/gui.rb'
+require_relative './plot/plot.rb'
+
+# Main module
+module STFTSpectrogram
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: stft_spectrogram
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jakub Javurek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-gnuplot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: wavefile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: fxruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.39
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.39
+description: Gui application for creating time-frequency spectrograms from wave files
+email: javurjak@fit.cvut.cz
+executables:
+- stft_spectrogram
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/stft_spectrogram
+- lib/audio/audio_file.rb
+- lib/gui/gui.rb
+- lib/plot/plot.rb
+- lib/stft/fft.rb
+- lib/stft/spectrogram.rb
+- lib/stft/stft_slice.rb
+- lib/stft_spectrogram.rb
+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.6.13
+signing_key: 
+specification_version: 4
+summary: App for creating spectrograms
+test_files: []