stuffs

python/transponge-gui.py

@@ -0,0 +1,261 @@
+# aggregate sound from mfcc or fft similarity of chunks
+
+import numpy as np
+import scipy.io.wavfile
+from features import mfcc
+from features import logfbank
+from features import base
+import copy
+
+import platform;
+
+if int(platform.python_version_tuple()[0])>2:
+	from tkinter import *
+	from tkinter.filedialog import *
+	from tkinter.messagebox import *
+else:
+	from Tkinter import *
+	from tkFileDialog import *
+	from tkMessageBox import *
+
+
+source_dir = "../sound/source/"
+render_dir = "../sound/render/"
+version = "0.0.1"
+
+def msg(msg):
+    print(msg)
+
+def clear_msg():
+    pass
+
+def fadeinout(s,slength,elength):
+    s = copy.deepcopy(s)
+    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 chop(wav,size,overlap,rand):
+    ret = []
+    pos = 0
+    seg = []
+    samples = wav[1]
+    while (pos+size<len(samples)):
+        ret.append([0,fadeinout(samples[pos:pos+size],500,500)])
+        pos+=(size-overlap)
+    return ret
+
+def fftify(chopped):
+    return map(lambda i: np.fft.fft(i[1]), chopped)
+
+def mfccify(chopped,rate):
+    ret = []
+    for sig in chopped:
+        ret.append(logfbank(sig[1],rate))
+    return ret
+
+def fftdiff(a,b):
+    return (abs(a-b)).sum(dtype=np.float128)
+
+def diffify(a,b):
+    return map(lambda a,b: fftdiff(a,b), a, b)
+
+def search(fft,bank):
+    closest = 99999999999999999
+    ret = -1
+    for i,tfft in enumerate(bank):
+        dist = fftdiff(fft,tfft)
+        if dist<closest:
+            ret = i
+            closest = dist
+    msg(str(ret))
+    return ret
+
+#unit_test()
+
+class transponge():
+    def __init__(self):
+        self.src=[]
+        self.dst=[0,[]]
+        self.src_chp=[]
+        self.dst_chp=[]
+        self.src_fft=[]
+        self.dst_fft=[]
+
+    def set_target(self,dst_filename):
+        self.dst = scipy.io.wavfile.read(dst_filename)
+        msg("succesfully loaded "+dst_filename+" as the target")
+
+    def add_source(self,src_filename):
+        self.src.append(scipy.io.wavfile.read(src_filename))
+        msg("succesfully loaded "+src_filename+" as a source")
+        msg("(now have "+str(len(self.src))+" sounds in brain...)")
+
+    def prepare(self,chp_size,chp_overlap,mfcc):
+        self.chp_size = chp_size
+        self.chp_overlap = chp_overlap
+
+        msg("chopping up target wav...")
+        self.dst_chp = chop(self.dst,self.chp_size,self.chp_overlap,0)
+        msg("number of target blocks: "+str(len(self.dst_chp)))
+
+        msg("processing target blocks")
+
+        if mfcc:
+            self.dst_fft = mfccify(self.dst_chp,self.dst[0])
+        else:
+            self.dst_fft = fftify(self.dst_chp)
+
+        self.dst_chp = [] # clear
+        self.dst_size = len(self.dst[1])
+
+        for i,src in enumerate(self.src):
+            msg("chopping up source wav no. "+str(i+1))
+            chopped=chop(src,self.chp_size,self.chp_overlap,0)
+            msg("number of target blocks: "+str(len(chopped)))
+            self.src_chp+=chopped
+            if mfcc:
+                self.src_fft+=mfccify(chopped,src[0])
+            else:
+                self.src_fft+=fftify(chopped)
+
+            msg("total number of source blocks now: "+str(len(self.dst_fft)))
+
+
+    def process(self,filename):
+        out = np.zeros(self.dst_size,dtype=self.src_chp[0][1].dtype)
+        pos = 0
+        for i,seg in enumerate(self.dst_fft):
+            # collect indices of closest sections
+            ii = search(seg,self.src_fft)
+            clear_msg()
+            for s in range(0,self.chp_size):
+                if pos+s<self.dst_size:
+                    sample = self.src_chp[ii][1][s]
+                    out[pos+s]=out[pos+s]+(sample*0.25)
+            pos+=(self.chp_size-self.chp_overlap)
+            msg(str((i/float(len(self.dst_fft)))*100.0)[:5]+"%")
+            if i%10==0: scipy.io.wavfile.write(render_dir+filename,44100,out)
+
+
+
+class win:
+    def __init__(self):
+        self.sponge = transponge()
+
+        # create window
+        self.root = Tk()
+        self.root.title("transpongerator brain "+version)
+        f=Frame(self.root)
+        f.pack(fill=NONE);
+        Button(f, text="load a source", command=self.load_source).grid(row=0, column=0, sticky="we")
+        Button(f, text="load the target", command=self.load_target).grid(row=0, column=1, sticky="we")
+        self.run_button = Button(f, text="run", command=self.run)
+        self.run_button.grid(row=0, column=2, sticky="we")
+        self.mfcc_var = IntVar()
+        cb=Checkbutton(f, text="use mfcc", variable=self.mfcc_var, command=self.mfcc)
+        cb.grid(row=1, column=0)
+        cb.select()
+
+        rf = Frame(f)
+        rf.grid(row=1, column=3)
+        Label(rf, text="overlap").grid(row=0,column=0)
+        self.overlap_entry = Entry(rf, width=5)
+        self.overlap_entry.grid(row=1, column=0)
+        self.overlap_entry.bind("<Return>", self.on_overlap)
+        self.overlap_entry.delete(0, END)
+        self.overlap_entry.insert(0, "0.75")
+        self.overlap=0.75
+
+        rf = Frame(f)
+        rf.grid(row=1, column=4)
+        Label(rf, text="window size").grid(row=0,column=0)
+        self.window_entry = Entry(rf, width=5)
+        self.window_entry.grid(row=1, column=0)
+        self.window_entry.bind("<Return>", self.on_window_size)
+        self.window_entry.delete(0, END)
+        self.window_entry.insert(0, "3000")
+        self.window_size=3000
+
+
+        self.debug = Text(self.root, font = "Helvetica 24 bold", height=10, width=60)
+        self.debug.pack()
+        self.debug.insert(END, "ready...\n")
+
+        #Label(lf, text="Branch length").grid(row=0,column=0)
+        #self.length_scale = Scale(lf, from_=0, to=100, orient=HORIZONTAL, command=self.on_length)
+        #self.length_scale.grid(row=1, column=0)
+        #self.length_scale.set(30)
+
+        #t.grid_rowconfigure(1,weight=0)
+        # start event loop
+
+
+    def msg(self,msg):
+        self.debug.insert(0.0, msg+"\n")
+        self.root.update()
+
+    def clear_msg(self):
+        self.debug.delete(0.0, END)
+        self.root.update()
+
+    def load_target(self):
+        filename = askopenfilename(title = "load target wav")
+        if filename!="":
+            self.sponge.set_target(filename)
+
+    def load_source(self):
+        filename = askopenfilename(title = "load source wav into brain")
+        if filename!="":
+            self.sponge.add_source(filename)
+
+    def on_window_size(self,event):
+        try:
+            self.window_size = float(self.window_entry.get())
+        except:
+            pass
+
+    def on_overlap(self,event):
+        try:
+            self.overlap = float(self.overlap_entry.get())
+        except:
+            pass
+
+    def run(self):
+        self.msg("preparing: windowsize: "+str(self.window_size))
+        self.msg("overlap: "+str(self.overlap))
+        self.sponge.prepare(int(self.window_size),int(self.window_size*self.overlap),self.mfcc_var.get()==1)
+        msg("processing...")
+        self.sponge.process("brain_out.wav")
+        msg("done, saved in brain_out.wav")
+
+
+
+    def mfcc(self):
+        pass
+
+
+w = win()
+
+msg = w.msg
+clear_msg = w.clear_msg
+
+try:
+    w.root.mainloop()
+except Exception,e:
+    msg(e)