rubySC 0.6.0 → 0.8.0

data/lib/rubySC.rb

@@ -6,6 +6,8 @@ Dir.glob("rubySC/**/*") { |file|
   require_relative file end
 }   
 
+require 'set'
+
 require 'active_support'
 require 'singleton'
 require 'osc-ruby'
@@ -25,7 +27,7 @@ class SC
   cattr_reader :listeVoix, :valeurReceptrice
   cattr_accessor :server, :portSuperCollider
 
-  include Singleton
+  #include Singleton
 
   # ouvre le contact avec SuperCollider
 
@@ -102,6 +104,11 @@ class SC
       self.send "Pbindef(\\#{voix}, \\#{arg}, Scale.#{value})"
     when "instrument"
       self.send "Pbindef(\\#{voix}, \\#{arg}, \\#{value})"
+    when "adsr"
+      self.send "Pbindef(\\#{voix}, \\atk, Pkey(\\dur)*#{value[0]})"
+      self.send "Pbindef(\\#{voix}, \\decay, Pkey(\\dur)*#{value[1]})"
+      self.send "Pbindef(\\#{voix}, \\sustain, Pkey(\\dur)*#{value[2]})"
+      self.send "Pbindef(\\#{voix}, \\rel, Pkey(\\dur)*#{value[3]})"
     else
       #self.send "Pbindef(\\#{voix}, \\#{arg}, #{value.to_s})"
     end
@@ -116,6 +123,12 @@ class SC
     end
   end
 
+def self.sample nomSample
+
+  tmp="samples/#{nomSample}.wav"
+  self.send "Buffer.read(s, \"#{tmp}\")"
+  
+end
   # fonctions principales
 
   public
@@ -126,10 +139,11 @@ class SC
 
     if args[0]==nil then
       args=@@listeVoix.keys
-      args.each do |voix|
-        self.send "Pdef(\\#{voix.to_s}).play"
-      end
     end
+    args.each do |voix|
+    self.send "Pdef(\\#{voix.to_s}).play"
+    end
+    
   end
 
 
@@ -154,4 +168,28 @@ class SC
 
 end
 
-SC.demarrer
+
+module Helper
+## quelques helpers
+
+def m numero=1
+  SC.listeVoix["melodie#{numero}"]
+end
+
+def org numero=1
+  SC.listeVoix["harmonisationDemelodie#{numero}"]
+end
+
+def h numero=0
+  SC.listeVoix["harmo#{numero}"]
+end
+
+def b
+SC.listeVoix["basse"]
+end
+
+def li
+  SC.listeVoix
+end
+
+end

data/lib/rubySC/forme.rb

@@ -0,0 +1,9 @@
+module Forme
+
+def globale
+
+	#AABA
+	
+end
+
+end

data/lib/rubySC/harmonie.rb

@@ -0,0 +1,56 @@
+module Harmonie
+
+include Intervalles
+
+	def squeletteHarmonique mel, set=[0,2,4]
+
+		mel.map { |e| 
+		e == set.any? ? true : false }
+	end
+
+	# Sert à détecter quel accord sous-tend une mélodie
+	# @format melodie [Melodie]
+	
+	def detecterSet mel, intervalles=2
+
+		tmpUn=mel.sort.uniq.map { |e|
+			e%intervalles
+		}
+		tmpDeux=mel.sort.uniq.map { |e|
+			e/intervalles
+		}
+		n={}
+		tmpUn.size.times do |x|
+			n[tmpUn[x].to_s].nil? ? \
+			(n[tmpUn[x].to_s] = [] << tmpDeux[x]) :\
+			(n[tmpUn[x].to_s] << tmpDeux[x])
+		end
+		return n
+	end
+
+	def detectSymetrie mel
+		
+	end
+
+	def analyse mel, grilleAnalyse=2, modulo=7
+
+		mel.each_slice(grilleAnalyse).map { |x|
+		 	(x[-1]-x[0])%7
+		  }
+			
+	end
+
+# Je ne sais pas si cette fonction a du sens, vraiment
+	def analyseReduction mel, nbRecursion=mel.size-1, tmp=[]
+
+		tmp << mel
+		unless nbRecursion<1
+		analyseReduction (mel.each_cons(2).map { |x|
+		 	(x[-1]-x[0])
+		}), nbRecursion-=1, tmp
+		end
+		return tmp
+	end
+
+
+end

data/lib/rubySC/harmonie/accords.rb

@@ -0,0 +1,46 @@
+#simplement un ensemble de voix marchant en simultanée
+# mais selon une logique harmonique => une basse !
+
+class Accords
+include VoiceLeading
+
+attr_accessor :grille
+
+	def initialize grille:, nbVoix:3, rythmeHarmonique:nil
+		@basse=grille
+		@realisation=Array.new(nbVoix) { |i| i=[]  }
+		@rythmeHarmonique=rythmeHarmonique
+		self.realiserAccords
+	end
+
+	def play 
+		3.times do |i|
+		Voix.new "harmo#{i}", {:instrument =>"default",
+								   :degree => @realisation[i],
+								   :dur => @rythmeHarmonique}
+		end
+		Voix.new "basse", {:instrument => "fatsaw", 
+						   :degree =>@basse,
+						   :dur => @rythmeHarmonique}
+		#if jouer? ? SC.play : nil
+	end
+	
+
+private def foutreDansReal truc #bon j'en ai marre, OK ?
+	tmp=dispatchNotes truc 
+	truc.size.times do |i|	
+	@realisation[i] << truc [i]
+	end	
+end
+
+	def realiserAccords
+		tmp=accordBasique @basse[0]
+		foutreDansReal tmp
+		grille=reduireGrille @basse
+		p grille
+		grille.each { |e| 
+		tmp=incrementer tmp, e
+		p tmp
+		foutreDansReal tmp }
+	end
+end

data/lib/rubySC/harmonie/harmonie.rb

@@ -0,0 +1,55 @@
+module Harmonie
+
+include Intervalles
+
+	def squeletteHarmonique mel, set=[0,2,4]
+
+		mel.map { |e| 
+		set.any? {|x| e==x} ? true : false }
+	end
+
+	# Sert à détecter les notes paires dans une section de
+	#mélodie. Retourne la distance qui sépare ces notes
+	#typiquement, un accord parfait sera {"0 (ou 1)" => [0,1,2]}
+	# @format melodie [Melodie]
+	
+	def detecterHarmonies mel, intervalles=2
+
+		tmpUn=mel.sort.uniq.map { |e|
+			e%intervalles
+		}
+		tmpDeux=mel.sort.uniq.map { |e|
+			e/intervalles
+		}
+		n={}
+		tmpUn.size.times do |x|
+			n[tmpUn[x].to_s].nil? ? \
+			(n[tmpUn[x].to_s] = [] << tmpDeux[x]) :\
+			(n[tmpUn[x].to_s] << tmpDeux[x])
+		end
+		return n
+	end
+
+
+	def analyse mel, grilleAnalyse=2, modulo=7
+
+		mel.each_slice(grilleAnalyse).map { |x|
+		 	(x[-1]-x[0])%7
+		  }
+			
+	end
+
+# Je ne sais pas si cette fonction a du sens, vraiment
+	def analyseReduction mel, nbRecursion=mel.size-1, tmp=[]
+
+		tmp << mel
+		unless nbRecursion<1
+		analyseReduction (mel.each_cons(2).map { |x|
+		 	(x[-1]-x[0])
+		}), nbRecursion-=1, tmp
+		end
+		return tmp
+	end
+
+
+end

data/lib/rubySC/harmonie/voiceLeading.rb

@@ -0,0 +1,128 @@
+require_relative '../melodie/intervalles.rb'
+
+module VoiceLeading
+include Intervalles
+
+	@@position = [[2,4], [2, 5],[3,5]]
+		#ALLLLLLLLLLLEZ
+	
+
+	#DoubleArray de Hash. Selon la position (place dans l'array),
+	#puis selon le vecteur (de -3 a 3) on a une position et éventuellement
+	#un changement de basse
+
+	chgtPos = [
+		[[2,-1],[1,0],[0,-1],nil,[0,+1],[1,-1],[2,+0]],
+		[[2,-1],[2,+0],[2,+1],nil,[1,+1],[0,0],[0,+1]],
+		[[0,0],[0,+1],[2,-1],nil,[2,+1],[1,+0],[1,+1]]
+	]
+
+	@@matricePos=[]
+	3.times do |j|
+		@@matricePos[j]=
+	h=Hash.new 
+	(-3..3).each do |i|
+		h[i]=chgtPos[j][i+3]
+		end
+	end
+
+
+#VOICE_LEAD_POS=[[0,2,4], [0, 2, 5],[0,3,5]]
+
+#réduit la grille d'accords autour d'une oscillation entre -3 et 3
+#pour faire en tout 7 valeurs possibles, aka le nombre de notes dans la 
+#gamme diatonique
+
+def reduireGrille grille, grilleAnalyse=7
+	minMax = grilleAnalyse/2
+	(intervalles grille).map { |e| 
+	e=e%grilleAnalyse
+	if e > minMax
+	e=-(grilleAnalyse%e)
+	elsif e < -minMax
+ 	e=(grilleAnalyse%e).abs 
+ 	else e
+    end
+	}
+end
+
+
+def incrementer accord, vecteurHarmonique
+
+#	binding.pry
+	position_basse=@@matricePos[(detectPosition accord)][vecteurHarmonique]
+	
+	accordNv=[]
+	if position_basse.nil?
+		accordNv=accord
+	else
+	accordNv[0]=accord[0]+position_basse[1]
+	accordNv[1]=accordNv[0]+@@position[position_basse[0]][0]
+	accordNv[2]=accordNv[0]+@@position[position_basse[0]][1]
+	end
+	return accordNv
+end
+
+def detectPosition array
+	tmp=[]
+	tmp<< array[1]-array[0]
+	tmp<< array[2]-array[0]
+	case tmp
+		when [2,4] 
+			return 0
+		when [2,5] 
+			return 1
+		when [3,5] 
+			return 2
+	end
+end
+
+# implémente selon le "vecteur harmonique" le passage d'un accord à un autre
+
+# def incrementer accord, vecteurHarmonique
+
+# plus=lambda{|x| x+1}
+# moins= lambda{|x| x-1}
+
+# 	case vecteurHarmonique
+# 	when 0
+# 		return accord
+# 	when 1 	
+# 		return accord.map! {|x| plus.call x}
+# 	when -1
+# 		return accord.map! {|x| moins.call x}	
+# 	when 2
+# 		accord[0]-=1
+# 		return accord
+# 	when -2
+# 		accord[-1]+=1
+# 		return accord
+# 	when 3	
+# 		accord[-1]+=1
+# 		accord[-2]+=1
+# 		return accord
+# 	when -3 
+# 		accord[0]-=1
+# 		accord[1]-=1
+# 		return accord
+# 	end	
+# end
+
+
+def accordBasique basse, position=nbNotes=3, intervalleBase=2 
+	
+	tmp=[]
+	nbNotes.times do |x|
+		tmp << basse+intervalleBase*x
+	end
+	return tmp
+end
+
+def dispatchNotes accord
+	tmp=[]
+	accord.each { |e| 
+	tmp << [e] }
+	return tmp
+end
+
+ end

data/lib/rubySC/math.rb

@@ -0,0 +1,5 @@
+module Calcul
+
+
+
+end

data/lib/rubySC/melodie/Schenker.rb

@@ -0,0 +1,15 @@
+
+def melodieCachee melUn, melDeux
+
+  i=0  
+    tmpDeux=melUn.map {|x| 
+      if x == melDeux[i] then i +=1 ; true 
+      else false
+      end 
+    }
+    p tmpDeux
+  
+    if tmpDeux.count(true) == melDeux.size 
+    then tmpDeux
+    else  nil end
+end

data/lib/rubySC/melodie/{algos.rb → intervalles.rb}

@@ -1,14 +1,14 @@
-def intervallesMel melodie
+module Intervalles
+
+def intervalles melodie
 
   tmp=melodie.each_with_index.map{ |a, i|
     if melodie[i+1]
     then melodie[i+1]-a
     end
     }
-
   	tmp[0..-2]
 
-
 end
 
 def intervallesBoucle melodie
@@ -28,4 +28,22 @@ def intervallesRel melodie, note=0
 	ptDepart = melodie[note]
 	return melodie.map { |x| 
 		x-= ptDepart }
+end
+
+def squeletteIntervallique melodie, gdIntervalle=5, petitInter=1
+
+	i=intervalles melodie
+	i.map! { |e| 
+	 if e<=petitInter
+	 	e=0
+	 elsif
+	 	e>=gdIntervalle
+	 	e=2
+	 else
+	 	e=1
+	 end
+	}
+
+end
+
 end