stuffs

python/transponge-eigen.py

@@ -0,0 +1,198 @@
+# wierd eigensound approach - project into learned pca space
+
+# fft -> matrix -> ifft -> sound
+
+from magicsquares import *
+import numpy as np
+import scipy.io.wavfile
+import math
+
+source_dir = "../sound/source/"
+render_dir = "../sound/render/"
+
+def fadeinout(s,slength,elength):
+    for i in range(0,slength):
+        m = float(i)/slength;
+        s[i]*=m
+    for i in range(0,elength):
+        m = float(i)/elength;
+        s[(len(s)-1)-i]*=m
+    return s
+
+def normalise(s):
+    m = 0
+    p = 999999999999999999
+    for i in range(0,len(s)):
+        if m<s[i]: m=s[i]
+        if p>s[i]: p=s[i]
+    b = max(m,-p)
+    if b>0:
+        s/=float(b/10000.0)
+    return s
+
+def arr_to_fv(a):
+    vp = FloatVector(len(a))
+    for i in range(0,vp.Size()):
+        vp[i]=float(a[i])
+    return vp
+
+def fv_to_arr(a):
+    ret = np.zeros(a.Size(),dtype=np.float32)
+    for i in range(0,a.Size()):
+        ret[i]=a[i]
+    return ret
+
+def build_pca(filename,s):
+    pca = PCA(len(s[0]))
+    for i,v in enumerate(s):
+        print(i/float(len(s))*100.0)
+        pca.AddFeature(arr_to_fv(v))
+    print("making eigenmatrix")
+    pca.Calculate()
+    print("saving eigenmatrix")
+    f = OpenFile(filename, "wb")
+    pca.Save(f)
+    CloseFile(f)
+    return pca
+
+def load_pca(filename):
+    pca = PCA(1)
+    f = OpenFile(filename, "rb")
+    pca.Load(f)
+    CloseFile(f)
+    pca.Compress(2,40)
+    return pca
+
+def synth_sound(s,pca):
+    p = pca.Project(arr_to_fv(s))
+    #for i in range(0,p.Size()):
+    #    if i<50 and i>5: p[i]=0
+    #    if i>100: p[i]=0
+    s = pca.Synth(p)
+    return s
+
+def project_eigen_sound(pca,row,gain):
+    return fv_to_arr(pca.GetEigenTransform().GetRowVector(row)*gain)
+
+def fftify(chopped):
+    return map(lambda i: np.array(np.fft.fft(i),dtype=np.float32), chopped)
+
+def chop(wav,size,overlap):
+    ret = []
+    pos = 0
+    seg = []
+    samples = wav[1]
+    while (pos+size<len(samples)):
+        ret.append(samples[pos:pos+size]) # 50,100
+        pos+=(size-overlap)
+    return ret
+
+class transponge():
+    def __init__(self,chp_size,chp_overlap,dst_filename):
+        dst =  scipy.io.wavfile.read(dst_filename)
+        self.src_chp=[]
+        self.src_fft=[]
+        self.chp_size = chp_size
+        self.chp_overlap = chp_overlap
+        self.dst_chp = chop(dst,self.chp_size,self.chp_overlap)
+        self.dst_fft = fftify(self.dst_chp)
+        print(self.chp_overlap)
+        print (len(self.dst_chp))
+        self.dst_size = len(dst[1])
+
+    def add(self,src_filename):
+        src =  scipy.io.wavfile.read(src_filename)
+        src_chp=chop(src,self.chp_size,self.chp_overlap)
+        self.src_fft+=fftify(src_chp)
+        self.src_chp+=src_chp
+        print("src now: "+str(len(self.src_chp)))
+
+    def learn(self,filename):
+        scipy.io.wavfile.write(render_dir+"input.wav",44100,np.concatenate(self.src_fft))
+        self.pca = build_pca(filename,self.src_fft)
+
+    def load(self,filename):
+        self.pca = load_pca(filename)
+
+    def process(self):
+        out = np.zeros(self.dst_size,dtype=np.int16)
+        pos = 0
+        for i,seg in enumerate(self.dst_fft):
+            fft = fv_to_arr(synth_sound(seg,self.pca))
+            resynth = fadeinout(np.fft.ifft(fft),50,50)
+            print(resynth[55])
+            for s in range(0,self.chp_size):
+                if pos+s<self.dst_size:
+                    out[pos+s]+=resynth[s]
+            pos+=(self.chp_size-self.chp_overlap)
+            print((i/float(len(self.dst_chp)))*100.0)
+            if i%10==0: scipy.io.wavfile.write(render_dir+"pca-out-amen-wierd.wav",44100,out)
+
+    def process_eigensound(self,row):
+        print self.pca.GetEigenValues()[0]
+
+        out = []
+        for row in range(0,50):
+            for i in range(0,10):
+                #gain = (i/float(100)-0.5)*2
+                #gain = 1/self.pca.GetEigenValues()[row]
+                gain =100000
+                #print("gain:"+str(gain))
+                n = project_eigen_sound(self.pca,row,gain)
+
+                pcm = np.fft.ifft(n).astype(np.float32)
+                pcm*=3
+                print(pcm[0])
+
+
+                out.append(pcm)
+            scipy.io.wavfile.write(render_dir+"eigensound.wav",44100,np.concatenate(out).astype(np.int16))
+
+def run(l):
+    t = transponge(l,int(l*0.75),source_dir+"pw2.wav")
+
+#    t.add(source_dir+"full.wav")
+#    t.add(source_dir+"808.wav")
+#    t.add(source_dir+"amen_brother.wav")
+
+#    t.add(source_dir+"sailingbybit.wav")
+#    t.add(source_dir+"dreambit.wav")
+    #t.add(source_dir+"pw2.wav")
+
+    #print("learning")
+    #t.learn("amen-fft.pca")
+
+    #print("loading")
+    #t.load("sailingby-fft.pca")
+#    t.load("acid-fft.pca")
+    #t.load("full-fft.pca")
+#    t.load("808-fft.pca")
+
+    t.load("amen-fft.pca")
+
+
+    #t.process_eigensound(3)
+
+
+#    print("processing")
+    t.process()
+
+run(512)
+
+'''import matplotlib.pyplot as plt
+
+sound = scipy.io.wavfile.read(source_dir+"808.wav")[1]
+
+
+fourier = np.fft.fft(sound)
+n = len(sound)
+timestep = 0.01
+freq = np.fft.fftfreq(n, d=timestep)
+
+freq = freq.astype(np.float32)
+
+for i in range(0,1000):
+    print(freq[i])
+
+scipy.io.wavfile.write(render_dir+"fft.wav", 44100, freq)
+'''