rubySC 0.6.0 → 0.8.0

data/lib/rubySC/melodie/melodie.rb

@@ -1,112 +1,106 @@
+require_relative 'intervalles.rb'
+require_relative  'motif.rb'
+
 class Melodie
 
-attr_reader :dessinRythmique, :dessinMelodique
+include Intervalles
+include Motif
+
+attr_reader :dessinRythmique, :dessinMelodique, :analyse
 
 def initialize
-  @dessinMelodique = creerMelodie
-  @dessinRythmique = creerRythme @dessinMelodique
+  
   @@nbMel=0
+  @analyse={}
+
+  @dessinMelodique = creerMelodie
+  self.analyser
+  @dessinRythmique = self.creerRythme
+
 end
-  
-  def mettreVoix instrument="default"
-    @@nbMel+=1
-    Voix.new "melodie#{@@nbMel}", 
-    ({:instrument => instrument, 
-      :degree => @dessinMelodique,
-      :dur => @dessinRythmique})
 
-  end
 
+def enclencher instrument="default"
+  p "instrument sera #{instrument}"
+  @@nbMel+=1
+  Voix.new "melodie#{@@nbMel}", 
+  ({:instrument => instrument, 
+    :degree => @dessinMelodique,
+    :dur => @dessinRythmique})
 end
 
+def analyser
 
-def creerMelodie nbNote=rand(10..30)
+  @analyse["motifs"]=squeletteMotivique @dessinMelodique
+  @analyse["intervalles"]=squeletteIntervallique @dessinMelodique
+   
+end   
 
-  Array.new (nbNote) do |note|
-    note=[0,0,1,1,2,3,3,3,3,4,4,4,4,5,6].sample   #manière un peu bourrine de "pondérer" les notes possibles
+
+  
+def creerRythme options={:intervalles=>1, :motifs=>1} 
+  
+  tmp=[]
+  l=lambda {|x|
+  unless options[x].nil? 
+    tmp<<@analyse[x.to_s].map(&options[x].method(:*))
+  end}
+ 
+  options.each { |k,v|
+  l.call k  }
+ 
+  result=[]
+  (@dessinMelodique.size-1).times do |i|
+  result << tmp.map{ |row| row[i] }.reduce(&:+)
   end
-end
 
-def transpose melodie, deCombien
-    melodie.map { |e| e+= deCombien }
-end
+  return result
 
-def melodieCachee melUn, melDeux
+end
 
-  i=0  
-    tmpDeux=melUn.map {|x| 
-      if x == melDeux[i] then i +=1 ; true 
-      else false
-      end 
-    }
-    p tmpDeux
+def vitesse
   
-    if tmpDeux.count(true) == melDeux.size 
-    then tmpDeux
-    else  nil end
 end
 
-#grand moment de désarroi algorithmique
 
-# def creerMelodie squeletteRythmique, urMelodie=["c","b","a","g","f","e","d","c"]
+#quelques raccourcis
 
+def inter
+  intervalles @dessinMelodique
+end
 
-# squeletteRythmique.last=3 #déjà ça c'est réglé
-# squeletteRythmique.reverse!
+def interAbs
+  intervallesAbs @dessinMelodique
+end
 
-# melodie=[]
+def interRel note=0
+  intervallesMel @dessinMelodique, note
+end
 
-# notePrincipale
-# noteSecondaire
-# noteOrnementale
 
+def detectDoublons 
+  @dessinMelodique.map.with_index(1) { |e, i| 
+    unless i==@dessinMelodique.size
+    @dessinMelodique[i] - @dessinMelodique[i-1] == 0 ? true : false
+    end }[0..-2]
+end
 
-# UnVersUn = lambda { noteOrnementale+=1}
-# UnVersDeux = lambda { |a| orner squeletteRythmique(a.index-noteOrnementale) }
-# UnVersTrois
-# DeuxversUn
-# DeuxVersDeux
-# DeuxVersTrois
-# TroisVersUn
-# TRoisVersDeux
-# TroisVErsTRois
 
-# niveauUn=squeletteRythmique.each_cons(2) { |a,b|
-#   case b
-#     when 1
-#       case a
-#         when 1
-#           UnVersUn.call
-#         when 2
-#           UnVersDeux.call
-#         when 3
-#           UnVersTrois.call
-#         end
-#     when 2
-#       case a
-#         when 1
-#           DeuxVersUn.call
-#         when 2
-#           DeuxVersDeux.call
-#         when 3
-#           DeuxVersTrois.call
-#         end
-#     when 3
-#     case a
-#         when 1
-#           TroisVersUn.call
-#         when 2
-#           TroisVersDeux.call
-#         when 3
-#           TroisVersTrois.call
-#   end
+end
+
 
 
+def creerMelodie nbNote=rand(10..30)
 
-# melodie.reverse!
+  Array.new (nbNote) do |note|
+    note=[0,0,1,1,2,3,3,3,3,4,4,4,4,5,6].sample   #manière un peu bourrine de "pondérer" les notes possibles
+  end
+end
 
+def transpose melodie, deCombien
+    melodie.map { |e| e+= deCombien }
+end
 
-# end
 
 def rejoindre noteDepart, noteArrivee, nbTemps
 
@@ -146,32 +140,3 @@ trille = lambda { tmp= [note-1, note, note+1, note] }
   end
 
 end
-
-
-
-#analyse rythmique basique
-# si intervalle grand => pt d'appui
-# si note conjointes et/ou similaire => plus rapide
-#pour l'instant, pas de note d'approche
-
-
-def creerRythme melodie=nil  #analyse
-
-  if melodie.nil?
-  return  RubySC_CONST::Rythmes.sample
-  end
-
-  rythme = intervallesMel melodie
-  rythme.map! { |inter|
-    case inter.abs
-      when 1
-      note = 1
-
-    else
-      note=2
-    end
-  }
-  rythme << 4
-
-end
-

data/lib/rubySC/melodie/motif.rb

@@ -0,0 +1,73 @@
+module Motif
+
+def detectPattern melodie, filtreLongueur=3
+
+
+  	mel=(convertirABC melodie).join
+ 
+
+  siz = mel.length
+  tmp = []
+
+  (0..siz-1).each do |n|
+    (n..siz-1).each do |i|
+      tmp << mel[n..i]
+    end
+  end
+  tmp.to_set
+
+	result=Hash.new 
+	tmp.each_with_index { |e, i| 
+		result[tmp[i]]=(mel.scan /#{tmp[i]}/).size
+	 }
+
+
+	return result.select { |k,v| k.size>=filtreLongueur and v > 1}
+	
+end
+
+def convertirABC melodie, setChiffres=['c','d','e','f','g','a','b','c']
+
+	toutDansOctave melodie
+	return melodie.map { |e|
+		e= setChiffres[e]
+	}
+end
+
+def squeletteMotivique melodie
+
+  	mel=(convertirABC melodie).join
+	patterns=detectPattern melodie, 1
+
+	#on met en exergue les plus longs patterns qui se répètent
+	patterns=patterns.keys.group_by(&:size).reverse_each { |k,v|
+	v.each {|i|
+	mel.gsub!(/#{i}/, (k.to_s)*i.size) 
+	}
+	}
+
+		mel.gsub!(/[^\d]/, '0')
+	
+	return mel.chars.map(&:to_i)
+
+end
+
+
+# transforme une melodie reduite autour de quelques valeurs neg et pos
+# en une melodie uniquement positive
+# RQ : on ne transforme pas 7 en "0" !!
+def toutDansOctave grille, modulo=7
+
+return grille.map { |e| 
+	if e > modulo and e > 0
+	e-(modulo * (e/modulo))
+	elsif e < 0 and e > modulo
+	(modulo * (e/modulo))-e
+	else
+	e.abs
+	end
+}
+
+end
+
+end

data/lib/rubySC/musique.rb

@@ -9,18 +9,6 @@ module RubySC_CONST
   ## Quelques constantes, notamment pour les rythmes, c'est toujours
   ## plus pratique
 
-  ## Je n'ai mis que les rythmes qui me semblaient
-  ## les plus connus
-  Rythmes = []
-
-  ## Rythmes à 3 notes
-  Rythmes <<  Pavanne=[2,1,1]
-  Rythmes << Syncopette=[1,2,1]
-
-  Rythmes << Sicilienne=[3,1,2]
-  Rythmes << Chabada=[3,2,1]
-
-  Rythmes << Tresillo=[3,3,2]
 
 #########
 
@@ -143,31 +131,3 @@ module Echelle
   end
 
 end
-
-module Rythme
-
-  def self.Tempo vitesse
-    SC.send "TempoClock.default.tempo = #{vitesse}"
-  end
-
-  ## s'occupe du premier chiffre de la propriété "dur", c-à-d la vitesse
-  def self.mesure mesure, *voix
-    voix.each do |v|
-      tmp = SC.listeVoix[v.to_s].dur
-      tmp[0] = mesure
-      SC.set true, ({ "dur" => tmp }), v
-    end
-  end
-
-  ## s'occupe du deuxième chiffre de la propriété "dur", c-à-d la
-  ## gestalt rythmique.
-
-  def self.formule formule, *voix
-    voix.each do |v|
-      tmp = SC.listeVoix[v.to_s].dur
-      tmp[1] = formule
-      SC.set true, ({ "dur" => tmp }), v
-    end
-  end
-
-end

data/lib/rubySC/rythme.rb

@@ -0,0 +1,82 @@
+module Rythme
+
+
+  ## Je n'ai mis que les rythmes qui me semblaient
+  ## les plus connus
+  Rythmes = []
+
+  ## Rythmes à 3 notes
+  Rythmes <<  Pavanne=[2,1,1]
+  Rythmes << Syncopette=[1,2,1]
+
+  Rythmes << Sicilienne=[3,1,2]
+  Rythmes << Chabada=[3,2,1]
+
+  Rythmes << Tresillo=[3,3,2]
+
+
+	def funkyser
+		
+		#replace [cll] par betedecll
+	end
+	
+def calculDernierTemps formuleRythmique, nbMesure=4
+
+	tmp=formuleRythmique.reduce(&:+)
+	lastValue=0
+	if tmp%nbMesure !=0
+		until tmp%nbMesure==0
+			lastValue+=1
+			tmp+=lastValue
+		end
+	end
+	return formuleRythmique << lastValue
+end
+
+
+def creerRythme melodie=nil  #analyse
+
+  if melodie.nil?
+  return  RubySC_CONST::Rythmes.sample
+  end
+
+  rythme = intervallesMel melodie
+  rythme.map! { |inter|
+    case inter.abs
+      when 1
+      note = 1
+
+    else
+      note=2
+    end
+  }
+  rythme << 4
+
+end
+
+
+  def self.tempo vitesse
+    SC.send "TempoClock.default.tempo = #{vitesse}"
+  end
+
+  ## s'occupe du premier chiffre de la propriété "dur", c-à-d la vitesse
+  def self.mesure mesure, *voix
+    voix.each do |v|
+      tmp = SC.listeVoix[v.to_s].dur
+      tmp[0] = mesure
+      SC.set true, ({ "dur" => tmp }), v
+    end
+  end
+
+  ## s'occupe du deuxième chiffre de la propriété "dur", c-à-d la
+  ## gestalt rythmique.
+
+  def self.formule formule, *voix
+    voix.each do |v|
+      tmp = SC.listeVoix[v.to_s].dur
+      tmp[1] = formule
+      SC.set true, ({ "dur" => tmp }), v
+    end
+  end
+  
+end

data/lib/rubySC/version.rb

@@ -1,3 +1,3 @@
 module RubySC
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/rubySC/voix.rb

@@ -4,8 +4,8 @@
 
 class Voix
 
-  attr_accessor :information, :degree, :octave, :marche, :scale, :amp, :instrument, :name
-  attr_reader :dur
+  attr_accessor  :information, :degree, :octave, :marche, :scale, :amp, :instrument, :name
+  attr_reader :adsr, :dur
   def initialize nom=nil, options={}
 
     @information=nil ## cette information sert juste à stocker tout ce
@@ -23,7 +23,15 @@ class Voix
 
     SC.listeVoix[@name]=self
 
-    self.setDuree options["dur"]
+    @information="en pause \n"
+    self.setDuree options[:dur]
+
+    @adsr=[]
+    if options[:adsr].nil?
+      then self.setADSR 0.2,1,0.9,0.4
+      else  
+      selfADSR options[:adsr]      
+    end
 
     if options[:degree].nil?
       then @degree=Array.new(rand(1..5)) do |x| x=rand(12) end
@@ -31,62 +39,67 @@ class Voix
       @degree=options[:degree]
     end
 
-    if options["octave"].nil?
+    if options[:octave].nil?
       then @octave=4
     else
-      @octave=options["octave"]
+      @octave=options[:octave]
     end
 
-    if options["scale"].nil?
+    if options[:scale].nil?
       then @scale = "major"
     else
-      @scale=options["scale"]
+      @scale=options[:scale]
     end
-    if options["amp"].nil?
+    if options[:amp].nil?
       then @amp = "Pwhite(0.2,0.8)"
     else
-      @amp=options["amp"]
+      @amp=options[:amp]
     end
 
-    if options["instrument"].nil?
+    if options[:instrument].nil?
       then @instrument = "default"
+      p "pan!"
     else
-      @instrument=options["instrument"].to_s
+     self.setInstrument options[:instrument]
     end
 
     if options[:dur]
       self.setDuree options[:dur]
     end
-    self.setMarche options["marche"]
+
     SC.updateScore
 
   end
 
-  def set options
-    options.each do |key, value|
-      if value.is_a? Symbol
-        value=value.to_s
-      end
-      case key
-      when "dur"
-        self.setDuree value
-      when "marche"
-        self.setMarche value
-      else
-        self.instance_variable_set "@#{key}", value
-      end
-    end
+
+  def setADSR atk, dec, sus, rel
+  
+    @adsr=[(atk/1.0), (dec/1.0), (sus/1.0), (rel/1.0)]
     SC.updateScore
+
   end
 
-  def setMarche intervalles
-    if intervalles.nil?
-      @root=0
+  def setInstrument instrument
+
+    if instrument.is_a? Symbol  
+    @information = "le sample utilisé actuellement est #{instrument} \n"
+    SC.sample instrument.to_s
+    @instrument="sampler"
     else
-      @root="Pstutter(#{self.degree.size}, Pseq(#{intervalles}, inf))"
-    end
+    @instrument=instrument
+    end 
+  
   end
 
+
+  # def setMarche intervalles
+  #   if intervalles.nil?
+  #     @root=0
+  #   else
+  #     @root="Pstutter(#{self.degree.size}, Pseq(#{intervalles}, inf))"
+  #   end
+  # end
+
   def setDuree (duree)
 
    if duree.nil?
@@ -127,9 +140,9 @@ class Voix
   end
 
   def play
+    SC.updateScore
     SC.play @name
-    @information="en train de jouer".colorize (:blue)
-
+    @information="en train de jouer"
   end
 
 end