kuromusic 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88c575d4c2225a5beb8d75be9e12d85a8fb0d319
-  data.tar.gz: 73347be8d64387812c8f06b4371e76c81154d5e8
+  metadata.gz: 8db1094e3fb4f19902a4bb5c15aba0c6639eecc7
+  data.tar.gz: cbc36b3a67c2665aaf004567df380be12632dff5
 SHA512:
-  metadata.gz: 663b0c54a70421da648756bd07eb421db0bdf1cca094e61e4e08b9b07b57c0ba65cf22fd63e81764160b16aa5c22ecbe1b5768983ed19802e7ba8ec68496943e
-  data.tar.gz: aec00d04e584d9d925b405cdf470587a3df815cc6de092458177ec7de80995c55a620f7f883275eb83cd723f83907d8e48b711e802151c215d4e0cabf96fd4e4
+  metadata.gz: 8454abcb46e6d7900b839e9754efaec96d567b9d4a2b6625f8ffc2a14d5388c97a9761ff5771eab52674fc44c32652ae2718c0fb9e0a2b0a30d90ca6bd60ef84
+  data.tar.gz: ad702556dd8746de404afece9e66d87f33395e0d6dbda8964fd8d1533bd104ced6a75a65000a5a70152b76376b4a83107eb6d99026c6447034fec2cd469a34d6

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 *.mid
+/archives/

data/README.md

@@ -1,9 +1,9 @@
 # KuroMusic
 
-KuroMusic is midi controll library writed by ruby.
+KuroMusic is midi controll library written by ruby.
 
 ##version
-0.0.2
+0.0.3
 
 ## Installation
 
@@ -28,22 +28,30 @@ you should require KuroMusic in your source code to use those method.
 require "KuroMusic"
 ```
 
-###generating melody on yourself
+###define DELTA TIME
+
+you should define delta time.
+delta time is imaginary time as quarter note used in MIDI.
 ```ruby:
 DELTA_TIME = 480
+```
+
+###generating melody on yourself
+```ruby:
 midi = Midi.new(DELTA_TIME, 1)
 chords1 = [
-  Chord.new([Note.new("A", 4, 100, 480),Note.new("C", 4, 100, 480),Note.new("E", 4, 100, 480)]),
-  Chord.new([Note.new("B", 4, 100, 480),Note.new("D", 4, 100, 480),Note.new("F", 4, 100, 480)]),
-  Chord.new([Note.new("C", 4, 100, 480),Note.new("E", 4, 100, 480),Note.new("G", 4, 100, 480)]),
-  Chord.new([Note.new("D", 4, 100, 480),Note.new("F", 4, 100, 480),Note.new("A", 4, 100, 480)]),
+  Chord.new([Note.new(-3, 4, 100, 480),Note.new(0, 4, 100, 480),Note.new(4, 4, 100, 480)]),
+  Chord.new([Note.new(-1, 4, 100, 480),Note.new(2, 4, 100, 480),Note.new(5, 4, 100, 480)]),
+  Chord.new([Note.new(0, 4, 100, 480),Note.new(4, 4, 100, 480),Note.new(7, 4, 100, 480)]),
+  Chord.new([Note.new(2, 4, 100, 480),Note.new(5, 4, 100, 480),Note.new(9, 4, 100, 480)]),
 ]
 chords2 = [
-  Chord.new([Note.new("E", 4, 100, 480),Note.new("G", 4, 100, 480),Note.new("B", 4, 100, 480)]),
-  Chord.new([Note.new("F", 4, 100, 480),Note.new("A", 4, 100, 480),Note.new("C", 4, 100, 480)]),
-  Chord.new([Note.new("G", 4, 100, 480),Note.new("B", 4, 100, 480),Note.new("D", 4, 100, 480)]),
+  Chord.new([Note.new(4, 4, 100, 480),Note.new(7, 4, 100, 480),Note.new(11, 4, 100, 480)]),
+  Chord.new([Note.new(5, 4, 100, 480),Note.new(9, 4, 100, 480),Note.new(0, 5, 100, 480)]),
+  Chord.new([Note.new(7, 4, 100, 480),Note.new(11, 4, 100, 480),Note.new(2, 5, 100, 480)]),
 ]
 midi.tracks[0] = Track.new(
+  Key::C::NATURAL,
   [
     Measure.new(chords1),
     Measure.new(chords2)
@@ -55,36 +63,77 @@ midi.tracks[0] = Track.new(
 ```ruby:
 DELTA_TIME = 480
 midi = Midi.new(DELTA_TIME, 2)
-melo = MelodyGenerater.new(DELTA_TIME, Scale::MAJOR).extend(MelodyGenerater::Schenker)
-midi.tracks[0] = melo.cantus(10)
-midi.tracks[1] = melo.base(10)
+melo = MelodyGenerater.new(DELTA_TIME, Key::E::NATURAL, Scale::MAJOR).extend(MelodyGenerater::Schenker)
+midi.tracks[0] = melo.generate(10, 4)
+midi.tracks[1] = melo.generate(10, 2)
 ```
 
 ###changing tempo
 ```ruby:
-can = melo.cantus(10)
-can[0].set_meta(Event::Meta::set_tempo(171))
+can_track = melo.generate(10, 4)
+can_track[0].set_meta(Event::Meta::set_tempo(171))
 ```
 
 ###connecting tracks
 ```ruby:
-a_can = melo.cantus(10)
-b_can = melo.cantus(10)
-midi.tracks[0] = a_can + b_can
-```
-
-###connecting tracks
-```ruby:
-a_can = melo.cantus(10)
-b_can = melo.cantus(10)
-midi.tracks[0] = a_can + b_can
+a_can_track = melo.generate(10, 4)
+b_can_track = melo.generate(10, 4)
+midi.tracks[0] = a_can_track + b_can_track
 ```
 
 ###write midi file
 ```ruby:
-Midi::IO.write("hoge3.mid", midi)
+Midi::IO.write("hoge.mid", midi)
 ```
 
+##reference
+###Note
+Note.new(degree, octave, velocity, duration)
+
+duration is based on delta time.
+
+###Chord
+Chord.new([Notes])
+
+###Measure
+Measure.new([Chords])
+
+###Track
+Track.new(key, [Measures])
+
+###Key
+- Key::C::NATURAL
+- Key::B::SHARP
+- Key::C::SHARP
+- Key::D::FLAT
+- Key::D::NATURAL
+- Key::D::SHARP
+- Key::E::FLAT
+- Key::E::NATURAL
+- Key::F::FLAT
+- Key::E::SHARP
+- Key::F::NATURAL
+- Key::C::FLAT
+- Key::B::NATURAL
+- Key::A::SHARP
+- Key::B::FLAT
+- Key::A::NATURAL
+- Key::A::FLAT
+- Key::G::SHARP
+- Key::G::NATURAL
+- Key::G::FLAT
+- Key::F::SHARP
+
+###Scale
+- Scale::MAJOR
+- Scale::MINOR
+- Scale::PENTATONIC
+- Scale::WHOLE_TONE
+- Scale::OKINAWA
+- Scale::INDIAN
+- Scale::GYPSY
+- Scale::KUMOI
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/kuromusic/fork )

data/lib/kuromusic/Generator/Random.rb

@@ -33,13 +33,8 @@ class MelodyGenerater
       end
 
     public
-      def base(length)
-        octave = 2
-        Track.new(common(length, octave, @note_times[4..5], @scale))
-      end
-      def cantus(length)
-        octave = 4
-        Track.new(common(length, octave, @note_times[1..3], @scale))
+      def generate(length, octave)
+        Track.new(@key, common(length, octave, @note_times[2..3], @scale))
       end
   end
 end

data/lib/kuromusic/Generator/Schenker.rb

@@ -11,9 +11,8 @@ class MelodyGenerater
               dur, velocity = Fiber.yield (0..(num-1)).to_a.map{|item|
                 _n = n + (2 * item)
                 octave = octave + _n / 12
-                number = _n % 12
-                note = Scale::number_to_code(number)
-                Note.new(note, octave, velocity, dur)
+                degree = _n % 12
+                Note.new(degree, octave, velocity, dur)
               }
             }
           end
@@ -42,14 +41,8 @@ class MelodyGenerater
       end
 
     public
-      def base(length)
-        octave = 2
-        Track.new(common(length, octave, @note_times[4..5], BACK))
-      end
-
-      def cantus(length)
-        octave = 4
-        Track.new(common(length, octave, @note_times[2..3], MIDDLE))
+      def generate(length, octave)
+        Track.new(@key, common(length, octave, @note_times[2..3], @scale))
       end
     end
 end

data/lib/kuromusic/IO/MIDI/Chord.rb

@@ -4,7 +4,7 @@ class Midi
   private
     module Chord
       public
-        def to_bin()
+        def to_bin(key)
           predur = 0
           ons = []
           offs = []
@@ -12,11 +12,11 @@ class Midi
           @notes.sort {|a, b|
             a.dur <=> b.dur
           }.each {|n|
-            ons += [::Event::Note::rest(0), n.get_on_event]
+            ons += [::Event::Note::rest(0), n.get_on_event(key)]
             maxdur = n.dur if maxdur < n.dur
           }.each {|n|
             currentdur = n.dur - predur
-            offs += [::Event::Note::rest(currentdur), n.get_off_event]
+            offs += [::Event::Note::rest(currentdur), n.get_off_event(key)]
             predur = n.dur
           }
           (ons + offs).map {|e|

data/lib/kuromusic/IO/MIDI/Measure.rb

@@ -4,13 +4,13 @@ require_relative "Event"
 class Midi
   private
     module Measure
-      def to_bin()
+      def to_bin(key)
         @metas.map {|m|
           m.extend(Midi::Event)
           m.to_bin
         }.flatten.concat @chords.map {|c|
           c.extend(Midi::Chord)
-          c.to_bin
+          c.to_bin(key)
         }.flatten!
       end
     end

data/lib/kuromusic/IO/MIDI/Track.rb

@@ -7,7 +7,7 @@ class Midi
         track = []
         @measures.each {|m|
           m.extend(Midi::Measure)
-          track.concat m.to_bin
+          track.concat m.to_bin(@key)
         }
         tl = track.concat([0, 0xff, 0x02, 0]).size
         result = [0x4d, 0x54, 0x72, 0x6b, tl >> 24, tl >> 16, tl >> 8, tl % 256].concat track

data/lib/kuromusic/Key.rb

@@ -1,3 +1,63 @@
-class Key
-  
+module Key extend self
+  module C extend self
+    NATURAL = "C"
+    SHARP = "C#"
+    FLAT = "Cb"
+  end
+  module D extend self
+    NATURAL = "D"
+    SHARP = "D#"
+    FLAT = "Db"
+  end
+  module E extend self
+    NATURAL = "E"
+    SHARP = "E#"
+    FLAT = "Eb"
+  end
+  module F extend self
+    NATURAL = "F"
+    SHARP = "F#"
+    FLAT = "Fb"
+  end
+  module G extend self
+    NATURAL = "G"
+    SHARP = "G#"
+    FLAT = "Gb"
+  end
+  module A extend self
+    NATURAL = "A"
+    SHARP = "A#"
+    FLAT = "Ab"
+  end
+  module B extend self
+    NATURAL = "B"
+    SHARP = "B#"
+    FLAT = "Bb"
+  end
+
+  def key_to_degree(key)
+    {
+      #positive
+      Key::C::NATURAL => 0, Key::B::SHARP => 0,
+      Key::C::SHARP => 1, Key::D::FLAT => 1,
+      Key::D::NATURAL => 2,
+      Key::D::SHARP => 3, Key::E::FLAT => 3,
+      Key::E::NATURAL => 4, Key::F::FLAT => 4,
+      Key::E::SHARP => 5, Key::F::NATURAL => 5,
+
+      #negative
+      Key::C::FLAT => -1, Key::B::NATURAL => -1,
+      Key::A::SHARP => -2, Key::B::FLAT => -2,
+      Key::A::NATURAL => -3,
+      Key::A::FLAT => -4, Key::G::SHARP => -4,
+      Key::G::NATURAL => -5,
+      Key::G::FLAT => -6, Key::F::SHARP => -6
+    }[key]
+  end
+
+  def degree_to_key(number)
+    {
+      0=>"C", 1=>"C#", 2=>"D", 3=>"D#", 4=>"E", 5=>"F", 6=>"F#", 7=>"G", 8=>"G#", 9=>"A", 10=>"A#", 11=>"B"
+    }[number % 12]
+  end
 end

data/lib/kuromusic/MelodyGenerater.rb

@@ -4,12 +4,11 @@ require_relative "Generator/Random"
 require_relative "Generator/Schenker"
 
 class MelodyGenerater
-  def initialize(dtime, scale, chord, key = nil)
-    @chord = chord
+  def initialize(dtime, key, scale)
     @dtime = dtime
     @note_times = [dtime/8, dtime/4, dtime/2, dtime, dtime*2, dtime*4]
-    @scale = scale
     @key = key
+    @scale = scale
     @measure = dtime * 4
   end
 end

data/lib/kuromusic/Scale.rb

@@ -1,20 +1,10 @@
 module Scale extend self
-  MAJOR = ["C", "D", "E", "F", "G", "A", "B"]
-  MINOR = ["C", "D", "D#", "F", "G", "G#", "B"]
-  PENTATONIC = ["C", "D", "E", "G", "A"]
-  WHOLE_TONE = ["C", "D", "E", "F#", "G#", "A#"]
-  OKINAWA = ["C", "E", "F", "G", "B"]
-  INDIAN = ["C", "C#", "E", "F#", "G", "A", "B"]
-  GYPSY = ["C", "C#", "E", "F", "G", "G#", "B"]
-  KUMOI = ["C", "D", "D#", "G", "A"]
-
-  def note_to_n(note)
-    map = {"C"=>0, "C#"=>1, "D"=>2, "D#"=>3, "E"=>4, "F"=>5, "F#"=>6, "G"=>7, "G#"=>8, "A"=>9, "A#"=>10, "B"=>11}
-    map[note]
-  end
-
-  def number_to_code(number)
-    map = {0=>"C", 1=>"C#", 2=>"D", 3=>"D#", 4=>"E", 5=>"F", 6=>"F#", 7=>"G", 8=>"G#", 9=>"A", 10=>"A#", 11=>"B"}
-    map[number]
-  end
+  MAJOR = [0, 2, 4, 5, 7, 9, 11]
+  MINOR = [0, 2, 3, 5, 7, 8, 11]
+  PENTATONIC = [0, 2, 4, 7, 9]
+  WHOLE_TONE = [0, 2, 4, 6, 8, 10]
+  OKINAWA = [0, 4, 5, 7, 11]
+  INDIAN = [0, 1, 4, 6, 7, 9, 11]
+  GYPSY = [0, 1, 4, 5, 7, 8, 11]
+  KUMOI = [0, 2, 3, 7, 9]
 end

data/lib/kuromusic/Track.rb

@@ -1,8 +1,10 @@
 require_relative "Object"
+require_relative "Key"
 require_relative "Track/Measure"
 
 class Track < Object
-  def initialize(measures = [])
+  def initialize(key, measures = [])
+    @key = key
     @measures = measures
   end
 
@@ -70,6 +72,10 @@ class Track < Object
     }
   end
 
+  def length()
+    @measure.length
+  end
+
   def +(other)
     tmp = []
     if other.class.to_s == "Track"
@@ -81,12 +87,16 @@ class Track < Object
     else
       self.error_puts("ArgumentTypeError", "undefined method `+'")
     end
-    Track.new(tmp)
+    Track.new(@key, tmp)
   end
 
   def inspect()
     "[
-  " + @measures.map{|m| m.inspect}.join("\n  ----------------------------------------------------------\n  ") + "
+  Track Meta: < key = #{@key} >
+  ----------------------------------------------------------
+  " + @measures.each_with_index.map{|m, i|
+    "Measure #{i+1}:\n" + m.inspect(@key)
+  }.join("\n  ----------------------------------------------------------\n  ") + "
 ]"
   end
 end

data/lib/kuromusic/Track/Measure.rb

@@ -16,11 +16,11 @@ class Measure < Object
     self
   end
 
-  def inspect()
-    "
-  " + @metas.map{|m| m.inspect}.join("\n  ),\n  (\n    ") + "
+  def inspect(key = nil)
+  "  Measure Meta:
+" + @metas.map{|m| "  " + m.inspect + "\n"}.join() + "
   (
-    " + @chords.map{|m| m.inspect}.join("\n  ),\n  (\n    ") + "
+    " + @chords.map{|m| m.inspect(key)}.join("\n  ),\n  (\n    ") + "
   )"
   end
 end

data/lib/kuromusic/Track/Measure/Chord.rb

@@ -5,7 +5,7 @@ class Chord < Object
     @notes = notes
   end
 
-  def inspect()
-    @notes.map{|n| n.inspect}.join(",\n    ")
+  def inspect(key = nil)
+    @notes.map{|n| n.inspect(key)}.join(",\n    ")
   end
 end

data/lib/kuromusic/Track/Measure/Chord/Note.rb

@@ -2,23 +2,42 @@ require_relative "Note/Event"
 
 class Note < Object
   attr_reader :note, :octave, :velocity, :dur
+  private
+    def get_gdeg_and_goct(key)
+      key_n = Key::key_to_degree(key)
+      gdeg = (key_n + @degree) % 12
+      if gdeg < 0
+        goct = @octave - 1
+      else
+        goct = @octave + (key_n + @degree) / 12
+      end
+      return gdeg, goct
+    end
+
   public
-    def initialize(note, octave, velocity, dur)
-      @note = note
+    def initialize(degree, octave, velocity, dur)
+      @degree = degree
       @octave = octave
       @dur = dur
       @velocity = velocity
     end
 
-    def get_on_event()
-      Event::Note::on(@note, @octave, @velocity)
+    def get_on_event(key)
+      gdeg, goct = get_gdeg_and_goct(key)
+      Event::Note::on(Key::degree_to_key(gdeg), goct, @velocity)
     end
 
-    def get_off_event()
-      Event::Note::off(@note, @octave)
+    def get_off_event(key)
+      gdeg, goct = get_gdeg_and_goct(key)
+      Event::Note::off(Key::degree_to_key(gdeg), goct)
     end
 
-    def inspect()
-      "<:note=>" + @note + ", :octave=>" + @octave.to_s + ", :velocity:=>" + @velocity.to_s + ", :duration=>" + @dur.to_s + ">"
+    def inspect(key = nil)
+      if key.nil?
+        "<:degree=>" + @degree.to_s + ", :octave=>" + @octave.to_s + ", :velocity:=>" + @velocity.to_s + ", :duration=>" + @dur.to_s + ">"
+      else
+        gdeg, goct = get_gdeg_and_goct(key)
+        "<:note=>" + Key::degree_to_key(gdeg) + ", :octave=>" + goct.to_s + ", :velocity:=>" + @velocity.to_s + ", :duration=>" + @dur.to_s + ">"
+      end
     end
 end

data/lib/kuromusic/version.rb

@@ -1,3 +1,3 @@
 module Kuromusic
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/sample/main.rb

@@ -2,18 +2,21 @@ require_relative "../KuroMusic"
 
 DELTA_TIME = 480
 midi = Midi.new(DELTA_TIME, 2)
-melo = MelodyGenerater.new(DELTA_TIME, Scale::MAJOR).extend(MelodyGenerater::Schenker)
+melo = MelodyGenerater.new(DELTA_TIME, Key::E::NATURAL, Scale::MAJOR).extend(MelodyGenerater::Rand)
 
-a_can = melo.cantus(5)
-a_can[0].set_meta(Event::Meta::set_tempo(171))
-b_can = melo.cantus(5)
-s_can = melo.cantus(10)
+a_can_track = melo.generate(5, 4)
+a_can_track[0].set_meta(Event::Meta::set_tempo(171))
+b_can_track = melo.generate(5, 4)
+s_can_track = melo.generate(10, 4)
 
-a_bas = melo.base(5)
-a_bas[0].set_meta(Event::Meta::set_tempo(171))
-b_bas = melo.base(5)
-s_bas = melo.base(10)
+a_bas_track = melo.generate(5, 2)
+a_bas_track[0].set_meta(Event::Meta::set_tempo(171))
+b_bas_track = melo.generate(5, 2)
+s_bas_track = melo.generate(10, 2)
 
-midi.tracks[0] = a_can + b_can + s_can + a_can + b_can + s_can + a_can
-midi.tracks[1] = a_bas + b_bas + s_bas + a_bas + b_bas + s_bas + a_bas
+midi.tracks[0] = a_can_track + b_can_track + s_can_track + a_can_track + b_can_track + s_can_track + a_can_track
+midi.tracks[1] = a_bas_track + b_bas_track + s_bas_track + a_bas_track + b_bas_track + s_bas_track + a_bas_track
+
+p midi.tracks[0]
+p midi.tracks[1]
 Midi::IO.write("../../hoge3.mid", midi)

data/lib/sample/main2.rb

@@ -3,17 +3,18 @@ require_relative "../KuroMusic"
 DELTA_TIME = 480
 midi = Midi.new(DELTA_TIME, 1)
 chords1 = [
-  Chord.new([Note.new("A", 4, 100, 480),Note.new("C", 4, 100, 480),Note.new("E", 4, 100, 480)]),
-  Chord.new([Note.new("B", 4, 100, 480),Note.new("D", 4, 100, 480),Note.new("F", 4, 100, 480)]),
-  Chord.new([Note.new("C", 4, 100, 480),Note.new("E", 4, 100, 480),Note.new("G", 4, 100, 480)]),
-  Chord.new([Note.new("D", 4, 100, 480),Note.new("F", 4, 100, 480),Note.new("A", 4, 100, 480)]),
+  Chord.new([Note.new(-3, 4, 100, 480),Note.new(0, 4, 100, 480),Note.new(4, 4, 100, 480)]),
+  Chord.new([Note.new(-1, 4, 100, 480),Note.new(2, 4, 100, 480),Note.new(5, 4, 100, 480)]),
+  Chord.new([Note.new(0, 4, 100, 480),Note.new(4, 4, 100, 480),Note.new(7, 4, 100, 480)]),
+  Chord.new([Note.new(2, 4, 100, 480),Note.new(5, 4, 100, 480),Note.new(9, 4, 100, 480)]),
 ]
 chords2 = [
-  Chord.new([Note.new("E", 4, 100, 480),Note.new("G", 4, 100, 480),Note.new("B", 4, 100, 480)]),
-  Chord.new([Note.new("F", 4, 100, 480),Note.new("A", 4, 100, 480),Note.new("C", 4, 100, 480)]),
-  Chord.new([Note.new("G", 4, 100, 480),Note.new("B", 4, 100, 480),Note.new("D", 4, 100, 480)]),
+  Chord.new([Note.new(4, 4, 100, 480),Note.new(7, 4, 100, 480),Note.new(11, 4, 100, 480)]),
+  Chord.new([Note.new(5, 4, 100, 480),Note.new(9, 4, 100, 480),Note.new(0, 5, 100, 480)]),
+  Chord.new([Note.new(7, 4, 100, 480),Note.new(11, 4, 100, 480),Note.new(2, 5, 100, 480)]),
 ]
 midi.tracks[0] = Track.new(
+  Key::C::NATURAL,
   [
     Measure.new(chords1),
     Measure.new(chords2)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuromusic
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - "黒澤 預生"
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2016-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler