# -*- coding: utf-8 -*-
"""
Created on Fri May 26 15:10:50 2017

@author: CarlSouthall
"""

import os
import inspect
import madmom
import numpy as np
import subprocess
from fpdf import FPDF
import ADTLib
import tensorflow as tf
from tensorflow.contrib import rnn

def spec(file):
    return madmom.audio.spectrogram.Spectrogram(file, frame_size=2048, hop_size=512, fft_size=2048,num_channels=1)
    
def meanPPmm(Track,Lambda,mi,ma,hop=512,fs=44100,dif=0.05):

    m=np.mean(Track)*Lambda;
    if ma != 0:
        if m>ma:
            m=ma
    if mi != 0:
        if m<mi:
            m=mi
    TrackNew=np.zeros(len(Track)+2)
    TrackNew[1:len(Track)+1]=Track
    Track=TrackNew
    onsets=[]
    values=[]
    for i in range(len(Track)-2):
        if Track[i+1] > Track[i] and Track[i+1]>=Track[i+2] and Track[i+1] > m:
            onsets=np.append(onsets,i+1)
            values=np.append(values,Track[i+1])
    if len(onsets) >0: 
        onsets=(onsets*hop)/float(fs)
    for i in range(1,len(onsets)):
        if abs(onsets[i]-onsets[i-1])<dif:
            ind=np.argmax(values[i-1:i+1])
            np.delete(onsets,onsets[i-1+ind])
  
    return onsets

def location_extract():
    return os.path.split((inspect.getfile(ADTLib)))[0]

def load_pp_param(save_path):
    cwd=os.getcwd()
    os.chdir(save_path+'/files')
    x=np.load('PPParams.npy')
    os.chdir(cwd)
    return x
    


def tab_create(Onsets,Filename_,save_dir_):
    quantisation_per_beat=4
    bars_per_line=4
    notation=['x','o','o']
    pre_trackname=Filename_.split('/')
    TrackName=pre_trackname[len(pre_trackname)-1].split('.')[0]+' Drum Tab'
    wav=Filename_.split('.')[0]+'.wav'
    subprocess.call(["DBNDownBeatTracker","single","-o","DB.txt",wav])

    DBFile=open("DB.txt")
    DBFile=DBFile.read().split('\n')
    DBFile=DBFile[:len(DBFile)-1]
    for i in range(len(DBFile)):
        DBFile[i]=DBFile[i].split('\t')
        DBFile[i]=np.array([float(DBFile[i][0]),int(DBFile[i][1])])
        
    grid=[]
    if len(DBFile)>0:
        max_beat=np.max(np.array(DBFile),0)[1]
        beat_dif=1/float(quantisation_per_beat)
        for i in range(len(DBFile)-1):
            k=np.arange(DBFile[i][0],DBFile[i+1][0],(DBFile[i+1][0]-DBFile[i][0])/float(quantisation_per_beat))
            beat_poss=DBFile[i][1]
            for j in k:
               if beat_poss >= max_beat:
                   beat_poss=0
               grid.append([j,beat_poss])
               beat_poss+=beat_dif
               
        quantisation_per_bar=int(max_beat*quantisation_per_beat)
        
        grid=np.array(grid)
        
        num_bars=np.ceil(grid.shape[0]/float(quantisation_per_bar))
        bar_grid=[]
        bar_start=np.expand_dims(np.transpose(['HH','SD','KD']),1)
        bar_end=np.expand_dims(np.transpose(['|','|','|']),1)
        for i in range(3):
            bar_grid.append(['|'])
            for j in range(quantisation_per_bar):
                    bar_grid[i].append('-')
        
        
        num_lines=np.int(np.floor(num_bars/float(bars_per_line)))
        last_line=num_bars%float(bars_per_line)
        lines=[]
        lines_new=[]
        for i in range(num_lines):
            lines.append(np.concatenate((bar_start,np.tile(bar_grid,int(bars_per_line)),bar_end),1))
            lines_new.append([])
            for j in range(len(lines[i])):
                lines[i][j]=list(lines[i][j])
        
        
        
        if last_line > 0:
            i+=1
            lines.append(np.concatenate((bar_start,np.tile(bar_grid,int(last_line)),bar_end),1))
            lines_new.append([])
            for j in range(len(lines[i])):
                lines[i][j]=list(lines[i][j])
        
                    
        
        
        onset_locations=[]
        onset_line=[]
        onset_bar_location=[]
        onset_tab_location=[]
        
        for i in range(len(Onsets)):
            onset_locations.append([])
            onset_line.append([])
            onset_tab_location.append([])
            onset_bar_location.append([])
            for j in range(len(Onsets[i])):
                onset_locations[i].append(np.argmin(np.abs(grid[:,0]-Onsets[i][j])))
                onset_line[i].append(np.floor(onset_locations[i][j]/(float(quantisation_per_bar*bars_per_line))))
                onset_bar_location[i].append((onset_locations[i][j]-((onset_line[i][j])*quantisation_per_bar*bars_per_line)))
                onset_tab_location[i].append(onset_bar_location[i][j]+2)
                for k in range(bars_per_line-1):
                    if onset_bar_location[i][j]>=(k+1)*quantisation_per_bar:
                        onset_tab_location[i][j]+=1
                lines[int(onset_line[i][j])][i][int(onset_tab_location[i][j])]=notation[i]
            
        lines_new=[]
        
        for i in range(len(lines)):
            lines_new.append([])
            for j in range(len(lines[i])):
                lines_new[i].append(''.join(lines[i][j]))  
                
        os.remove("DB.txt")
        if save_dir_!=None:
            current_dir=os.getcwd()
            os.chdir(save_dir_)
        pdf = FPDF(format='A4')
        pdf.add_page()
        pdf.set_font("Courier", size=12)
        pdf.cell(200, 10, txt=TrackName,ln=1, align="C")
        pdf.set_font("Courier", size=10)
        
        for i in range(len(lines_new)):
            for j in range(len(lines_new[i])):
                pdf.cell(0,3,txt=lines_new[i][j],ln=1,align="C")
            pdf.cell(0,5,txt='',ln=1,align="C")
        pdf.output(pre_trackname[len(pre_trackname)-1].split('.')[0]+'_drumtab.pdf')
        if save_dir_!=None:
            os.chdir(current_dir)
        
        
    else: 
        print('Error: No beat detected')

def tab_from_text(filename,save_dir):
    y=open(filename)
    lines=y.readlines()
    Peaks=[[],[],[]]
    ins=['KD','SD','HH']
    for i in range(len(lines)):
        lines[i]=lines[i].strip().split(' \t ')
        for j in range(len(ins)):
            if lines[i][1]==ins[j]:
                Peaks[j]=np.append(Peaks[j],float(lines[i][0]))
    
    
    tab_create([Peaks[2],Peaks[1],Peaks[0]],filename,save_dir)

def sort_ascending(x):
    in_re=[]
    out_re_final=[]
    in_symbols=['KD','SD','HH']
    for j in range(len(x)):
        in_re.append(np.concatenate(((np.expand_dims(x[j],1),np.tile(in_symbols[j],[len(x[j]),1]))),1))
    in_re=np.vstack(in_re)
    sorted_ind=(in_re[:,0]).astype(float).argsort()
    for j in sorted_ind:
        out_re_final.append([in_re[j]])
    out_re_final=np.squeeze(np.array(out_re_final))
    return out_re_final

def print_to_file(onsets,Filename,save_dir_):
    if save_dir_!=None:
        current_dir=os.getcwd()
        os.chdir(save_dir_)
    pre_trackname=Filename.split('/')
    f = open(pre_trackname[len(pre_trackname)-1].split('.')[0]+'.ADT.txt', "w")
    for item,item2 in onsets:
        f.write("%.4f \t %s \n" % (float(item), item2))
    if save_dir_!=None:
        os.chdir(current_dir)

    f.close()
    

           
class SA:
     
     def __init__(self, training_aug_data=[],training_data=[], training_labels=[], validation_data=[], validation_labels=[], mini_batch_locations=[], network_save_filename=[], minimum_epoch=5, maximum_epoch=10, n_hidden=[20,20], n_classes=2, cell_type='LSTMP', configuration='B', attention_number=2, dropout=0.75, init_method='zero', truncated=1000, optimizer='Adam', learning_rate=0.003 ,display_train_loss='True', display_accuracy='True',save_location=[],output_act='softmax',snippet_length=100,aug_prob=0):         
         self.train_aug=training_aug_data
         self.features=training_data
         self.targ=training_labels
         self.val=validation_data
         self.val_targ=validation_labels
         self.mini_batch_locations=mini_batch_locations
         self.filename=network_save_filename
         self.n_hidden=n_hidden
         self.n_layers=len(self.n_hidden)
         self.cell_type=cell_type
         self.dropout=dropout
         self.configuration=configuration
         self.init_method=init_method
         self.truncated=truncated
         self.optimizer=optimizer
         self.learning_rate=learning_rate
         self.n_classes=n_classes
         self.minimum_epoch=minimum_epoch
         self.maximum_epoch=maximum_epoch
         self.display_train_loss=display_train_loss
         self.num_batch=len(self.mini_batch_locations)
         self.batch_size=self.mini_batch_locations.shape[1]
         self.attention_number=attention_number
         self.display_accuracy=display_accuracy
         self.batch=np.zeros((self.batch_size,self.features.shape[1]))
         self.batch_targ=np.zeros((self.batch_size,self.targ.shape[2]))
         self.save_location=save_location
         self.output_act=output_act
         self.snippet_length=snippet_length
         self.aug_prob=aug_prob
  
     def cell_create(self,scope_name):
         with tf.variable_scope(scope_name):
             if self.cell_type == 'tanh':
                 cells = rnn.MultiRNNCell([rnn.BasicRNNCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'LSTM': 
                 cells = rnn.MultiRNNCell([rnn.BasicLSTMCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'GRU':
                 cells = rnn.MultiRNNCell([rnn.GRUCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'LSTMP':
                 cells = rnn.MultiRNNCell([rnn.LSTMCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             cells = rnn.DropoutWrapper(cells, input_keep_prob=self.dropout_ph,output_keep_prob=self.dropout_ph) 
         return cells
     
     def weight_bias_init(self):
               
         if self.init_method=='zero':
            self.biases = tf.Variable(tf.zeros([self.n_classes]))           
         elif self.init_method=='norm':
               self.biases = tf.Variable(tf.random_normal([self.n_classes]))           
         if self.configuration =='B':
             if self.init_method=='zero':  
                 self.weights =tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2, self.n_classes]))
             elif self.init_method=='norm':
                   self.weights = { '1': tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes])),'2': tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))} 
         if self.configuration =='R':
             if self.init_method=='zero':  
                 self.weights = tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))     
             elif self.init_method=='norm':
                   self.weights = tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))
      
     def attention_weight_init(self,num):
         if num==0:
             self.attention_weights=[tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*4,self.n_hidden[(len(self.n_hidden)-1)]*2]))]
             self.sm_attention_weights=[tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2,self.n_hidden[(len(self.n_hidden)-1)]*2]))]
         if num>0:
             self.attention_weights.append(tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*4,self.n_hidden[(len(self.n_hidden)-1)]*2])))
             self.sm_attention_weights.append(tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2,self.n_hidden[(len(self.n_hidden)-1)]*2])))
     def create(self):
       
       tf.reset_default_graph()
       self.weight_bias_init()
       self.x_ph = tf.placeholder("float32", [1, self.batch.shape[0], self.batch.shape[1]])
       self.y_ph = tf.placeholder("float32", self.batch_targ.shape)
       self.seq=tf.constant(self.truncated,shape=[1])
       self.seq2=tf.constant(self.truncated,shape=[1]) 
       self.dropout_ph = tf.placeholder("float32")
       self.fw_cell=self.cell_create('1')
       self.fw_cell2=self.cell_create('2')
       if self.configuration=='R':
           self.outputs, self.states= tf.nn.dynamic_rnn(self.fw_cell, self.x_ph,
                                             sequence_length=self.seq,dtype=tf.float32)
           if self.attention_number >0:
               self.outputs_zero_padded=tf.pad(self.outputs,[[0,0],[self.attention_number,0],[0,0]])
               self.RNNout1=tf.stack([tf.reshape(self.outputs_zero_padded[:,g:g+(self.attention_number+1)],[self.n_hidden[(len(self.n_hidden)-1)]*((self.attention_number)+1)]) for g in range(self.batch_size)])
               self.presoft=tf.matmul(self.RNNout1, self.weights) + self.biases
           else: 
               self.presoft=tf.matmul(self.outputs[0][0], self.weights) + self.biases
       elif self.configuration=='B':
           self.bw_cell=self.cell_create('1')
           self.bw_cell2=self.cell_create('2')
           with tf.variable_scope('1'):
               self.outputs, self.states= tf.nn.bidirectional_dynamic_rnn(self.fw_cell, self.bw_cell, self.x_ph,
                                             sequence_length=self.seq,dtype=tf.float32)
                                              
           self.first_out=tf.concat((self.outputs[0],self.outputs[1]),2)
           with tf.variable_scope('2'):
               self.outputs2, self.states2= tf.nn.bidirectional_dynamic_rnn(self.fw_cell2, self.bw_cell2, self.first_out,
                                                 sequence_length=self.seq2,dtype=tf.float32)
           self.second_out=tf.concat((self.outputs2[0],self.outputs2[1]),2)
            
           for i in range((self.attention_number*2)+1):
               self.attention_weight_init(i)
                
            
       
           self.zero_pad_second_out=tf.pad(tf.squeeze(self.second_out),[[self.attention_number,self.attention_number],[0,0]])
#               self.attention_chunks.append(self.zero_pad_second_out[j:j+attention_number*2])
           self.attention_m=[tf.tanh(tf.matmul(tf.concat((self.zero_pad_second_out[j:j+self.batch_size],tf.squeeze(self.first_out)),1),self.attention_weights[j])) for j in range((self.attention_number*2)+1)]
           self.attention_s=tf.nn.softmax(tf.stack([tf.matmul(self.attention_m[i],self.sm_attention_weights[i]) for i in range(self.attention_number*2+1)]),0)
           self.attention_z=tf.reduce_sum([self.attention_s[i]*self.zero_pad_second_out[i:self.batch_size+i] for i in range(self.attention_number*2+1)],0)
           self.presoft=tf.matmul(self.attention_z,self.weights)+self.biases
       if  self.output_act=='softmax':   
           self.pred=tf.nn.softmax(self.presoft)
           self.cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=self.presoft, labels=self.y_ph))
       elif self.output_act=='sigmoid':
           self.pred=tf.nn.sigmoid(self.presoft)
           self.cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=self.presoft, labels=self.y_ph))
       if self.optimizer == 'GD':
             self.optimize = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(self.cost)
       elif self.optimizer == 'Adam':
             self.optimize = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.cost) 
       elif self.optimizer == 'RMS':
             self.optimize = tf.train.RMSPropOptimizer(learning_rate=self.learning_rate).minimize(self.cost) 
       self.correct_pred = tf.equal(tf.argmax(self.pred,1), tf.argmax(self.y_ph,1))
       self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
       self.init = tf.global_variables_initializer()
       self.saver = tf.train.Saver()
       self.saver_var = tf.train.Saver(tf.trainable_variables())
       if self.save_location==[]:
           self.save_location=os.getcwd()
            
        
     def locations_create(self,size):
         self.locations=range(size)
         self.dif=size%self.batch_size
         if self.dif>0:
             for i in range(self.batch_size-self.dif):
                 self.locations=np.append(self.locations,0)
         self.location_new=np.reshape(self.locations,[-1,self.batch_size])     
         return self.location_new
 
       
     def implement(self,data):
         with tf.Session() as sess:
             self.saver.restore(sess, self.save_location+'/'+self.filename)
             self.test_out=[];
             for i in range(len(data)):
                 self.test_len=len(data[i])
                 self.test_locations=self.locations_create(self.test_len)
                 for k in range(len(self.test_locations)):
                    for j in range(self.batch_size):
                        self.batch[j]=data[i][self.test_locations[k,j]]
                    if k == 0:
                        self.test_out.append(sess.run(self.pred, feed_dict={self.x_ph: np.expand_dims(self.batch,0),self.dropout_ph:1}))                                    
                    elif k > 0:
                        self.test_out_2=sess.run(self.pred, feed_dict={self.x_ph: np.expand_dims(self.batch,0),self.dropout_ph:1})
                        self.test_out[i]=np.concatenate((self.test_out[i],self.test_out_2),axis=0)
                 self.test_out[i]=self.test_out[i][:self.test_len]
                  
         return self.test_out
                
def system_restore(data,save_path):
    ins=['Kick','Snare','Hihat']
    out=[]
    for i in ins:
        if i =='Kick':
            NN=SA([],np.zeros((1,1024)),np.zeros((1,1,2)),mini_batch_locations=np.zeros([1,1000]),network_save_filename=i+'ADTLibAll',save_location=save_path+"/files",cell_type='LSTMP',attention_number=2,n_hidden=[20,20],n_classes=2,truncated=1000,configuration='B',optimizer='GD')
            NN.create()
        NN.filename=i+'ADTLibAll'    
        out.append(NN.implement([data])[0])

    return out      
 

# -*- coding: utf-8 -*-
"""
Created on Fri May 26 15:10:50 2017

@author: CarlSouthall
"""

import os
import inspect
import madmom
import numpy as np
import subprocess
from fpdf import FPDF
import ADTLib
import tensorflow as tf
from tensorflow.contrib import rnn

def spec(file):
    return madmom.audio.spectrogram.Spectrogram(file, frame_size=2048, hop_size=512, fft_size=2048,num_channels=1)
    
def meanPPmm(Track,Lambda,mi,ma,hop=512,fs=44100,dif=0.05):

    m=np.mean(Track)*Lambda;
    if ma != 0:
        if m>ma:
            m=ma
    if mi != 0:
        if m<mi:
            m=mi
    TrackNew=np.zeros(len(Track)+2)
    TrackNew[1:len(Track)+1]=Track
    Track=TrackNew
    onsets=[]
    values=[]
    for i in range(len(Track)-2):
        if Track[i+1] > Track[i] and Track[i+1]>=Track[i+2] and Track[i+1] > m:
            onsets=np.append(onsets,i+1)
            values=np.append(values,Track[i+1])
    if len(onsets) >0: 
        onsets=(onsets*hop)/float(fs)
    for i in range(1,len(onsets)):
        if abs(onsets[i]-onsets[i-1])<dif:
            ind=np.argmax(values[i-1:i+1])
            np.delete(onsets,onsets[i-1+ind])
  
    return onsets

def location_extract():
    return os.path.split((inspect.getfile(ADTLib)))[0]

def load_pp_param(save_path):
    cwd=os.getcwd()
    os.chdir(save_path+'/files')
    x=np.load('PPParams.npy')
    os.chdir(cwd)
    return x
    


def tab_create(Onsets,Filename_,save_dir_):
    quantisation_per_beat=4
    bars_per_line=4
    notation=['x','o','o']
    pre_trackname=Filename_.split('/')
    TrackName=pre_trackname[len(pre_trackname)-1].split('.')[0]+' Drum Tab'
    wav=Filename_.split('.')[0]+'.wav'
    subprocess.call(["DBNDownBeatTracker","single","-o","DB.txt",wav])

    DBFile=open("DB.txt")
    DBFile=DBFile.read().split('\n')
    DBFile=DBFile[:len(DBFile)-1]
    for i in range(len(DBFile)):
        DBFile[i]=DBFile[i].split('\t')
        DBFile[i]=np.array([float(DBFile[i][0]),int(DBFile[i][1])])
        
    grid=[]
    if len(DBFile)>0:
        max_beat=np.max(np.array(DBFile),0)[1]
        beat_dif=1/float(quantisation_per_beat)
        for i in range(len(DBFile)-1):
            k=np.arange(DBFile[i][0],DBFile[i+1][0],(DBFile[i+1][0]-DBFile[i][0])/float(quantisation_per_beat))
            beat_poss=DBFile[i][1]
            for j in k:
               if beat_poss >= max_beat:
                   beat_poss=0
               grid.append([j,beat_poss])
               beat_poss+=beat_dif
               
        quantisation_per_bar=int(max_beat*quantisation_per_beat)
        
        grid=np.array(grid)
        
        num_bars=np.ceil(grid.shape[0]/float(quantisation_per_bar))
        bar_grid=[]
        bar_start=np.expand_dims(np.transpose(['HH','SD','KD']),1)
        bar_end=np.expand_dims(np.transpose(['|','|','|']),1)
        for i in range(3):
            bar_grid.append(['|'])
            for j in range(quantisation_per_bar):
                    bar_grid[i].append('-')
        
        
        num_lines=np.int(np.floor(num_bars/float(bars_per_line)))
        last_line=num_bars%float(bars_per_line)
        lines=[]
        lines_new=[]
        for i in range(num_lines):
            lines.append(np.concatenate((bar_start,np.tile(bar_grid,int(bars_per_line)),bar_end),1))
            lines_new.append([])
            for j in range(len(lines[i])):
                lines[i][j]=list(lines[i][j])
        
        
        
        if last_line > 0:
            i+=1
            lines.append(np.concatenate((bar_start,np.tile(bar_grid,int(last_line)),bar_end),1))
            lines_new.append([])
            for j in range(len(lines[i])):
                lines[i][j]=list(lines[i][j])
        
                    
        
        
        onset_locations=[]
        onset_line=[]
        onset_bar_location=[]
        onset_tab_location=[]
        
        for i in range(len(Onsets)):
            onset_locations.append([])
            onset_line.append([])
            onset_tab_location.append([])
            onset_bar_location.append([])
            for j in range(len(Onsets[i])):
                onset_locations[i].append(np.argmin(np.abs(grid[:,0]-Onsets[i][j])))
                onset_line[i].append(np.floor(onset_locations[i][j]/(float(quantisation_per_bar*bars_per_line))))
                onset_bar_location[i].append((onset_locations[i][j]-((onset_line[i][j])*quantisation_per_bar*bars_per_line)))
                onset_tab_location[i].append(onset_bar_location[i][j]+2)
                for k in range(bars_per_line-1):
                    if onset_bar_location[i][j]>=(k+1)*quantisation_per_bar:
                        onset_tab_location[i][j]+=1
                lines[int(onset_line[i][j])][i][int(onset_tab_location[i][j])]=notation[i]
            
        lines_new=[]
        
        for i in range(len(lines)):
            lines_new.append([])
            for j in range(len(lines[i])):
                lines_new[i].append(''.join(lines[i][j]))  
                
        os.remove("DB.txt")
        if save_dir_!=None:
            current_dir=os.getcwd()
            os.chdir(save_dir_)
        pdf = FPDF(format='A4')
        pdf.add_page()
        pdf.set_font("Courier", size=12)
        pdf.cell(200, 10, txt=TrackName,ln=1, align="C")
        pdf.set_font("Courier", size=10)
        
        for i in range(len(lines_new)):
            for j in range(len(lines_new[i])):
                pdf.cell(0,3,txt=lines_new[i][j],ln=1,align="C")
            pdf.cell(0,5,txt='',ln=1,align="C")
        pdf.output(pre_trackname[len(pre_trackname)-1].split('.')[0]+'_drumtab.pdf')
        if save_dir_!=None:
            os.chdir(current_dir)
        
        
    else: 
        print('Error: No beat detected')

def tab_from_text(filename,save_dir):
    y=open(filename)
    lines=y.readlines()
    Peaks=[[],[],[]]
    ins=['KD','SD','HH']
    for i in range(len(lines)):
        lines[i]=lines[i].strip().split(' \t ')
        for j in range(len(ins)):
            if lines[i][1]==ins[j]:
                Peaks[j]=np.append(Peaks[j],float(lines[i][0]))
    
    
    tab_create([Peaks[2],Peaks[1],Peaks[0]],filename,save_dir)

def sort_ascending(x):
    in_re=[]
    out_re_final=[]
    in_symbols=['KD','SD','HH']
    for j in range(len(x)):
        in_re.append(np.concatenate(((np.expand_dims(x[j],1),np.tile(in_symbols[j],[len(x[j]),1]))),1))
    in_re=np.vstack(in_re)
    sorted_ind=(in_re[:,0]).astype(float).argsort()
    for j in sorted_ind:
        out_re_final.append([in_re[j]])
    out_re_final=np.squeeze(np.array(out_re_final))
    return out_re_final

def print_to_file(onsets,Filename,save_dir_):
    if save_dir_!=None:
        current_dir=os.getcwd()
        os.chdir(save_dir_)
    pre_trackname=Filename.split('/')
    f = open(pre_trackname[len(pre_trackname)-1].split('.')[0]+'.ADT.txt', "w")
    for item,item2 in onsets:
        f.write("%.4f \t %s \n" % (float(item), item2))
    if save_dir_!=None:
        os.chdir(current_dir)

    f.close()
    

           
class SA:
     
     def __init__(self, training_aug_data=[],training_data=[], training_labels=[], validation_data=[], validation_labels=[], mini_batch_locations=[], network_save_filename=[], minimum_epoch=5, maximum_epoch=10, n_hidden=[20,20], n_classes=2, cell_type='LSTMP', configuration='B', attention_number=2, dropout=0.75, init_method='zero', truncated=1000, optimizer='Adam', learning_rate=0.003 ,display_train_loss='True', display_accuracy='True',save_location=[],output_act='softmax',snippet_length=100,aug_prob=0):         
         self.train_aug=training_aug_data
         self.features=training_data
         self.targ=training_labels
         self.val=validation_data
         self.val_targ=validation_labels
         self.mini_batch_locations=mini_batch_locations
         self.filename=network_save_filename
         self.n_hidden=n_hidden
         self.n_layers=len(self.n_hidden)
         self.cell_type=cell_type
         self.dropout=dropout
         self.configuration=configuration
         self.init_method=init_method
         self.truncated=truncated
         self.optimizer=optimizer
         self.learning_rate=learning_rate
         self.n_classes=n_classes
         self.minimum_epoch=minimum_epoch
         self.maximum_epoch=maximum_epoch
         self.display_train_loss=display_train_loss
         self.num_batch=len(self.mini_batch_locations)
         self.batch_size=self.mini_batch_locations.shape[1]
         self.attention_number=attention_number
         self.display_accuracy=display_accuracy
         self.batch=np.zeros((self.batch_size,self.features.shape[1]))
         self.batch_targ=np.zeros((self.batch_size,self.targ.shape[2]))
         self.save_location=save_location
         self.output_act=output_act
         self.snippet_length=snippet_length
         self.aug_prob=aug_prob
  
     def cell_create(self,scope_name):
         with tf.variable_scope(scope_name):
             if self.cell_type == 'tanh':
                 cells = rnn.MultiRNNCell([rnn.BasicRNNCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'LSTM': 
                 cells = rnn.MultiRNNCell([rnn.BasicLSTMCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'GRU':
                 cells = rnn.MultiRNNCell([rnn.GRUCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             elif self.cell_type == 'LSTMP':
                 cells = rnn.MultiRNNCell([rnn.LSTMCell(self.n_hidden[i]) for i in range(self.n_layers)], state_is_tuple=True)
             cells = rnn.DropoutWrapper(cells, input_keep_prob=self.dropout_ph,output_keep_prob=self.dropout_ph) 
         return cells
     
     def weight_bias_init(self):
               
         if self.init_method=='zero':
            self.biases = tf.Variable(tf.zeros([self.n_classes]))           
         elif self.init_method=='norm':
               self.biases = tf.Variable(tf.random_normal([self.n_classes]))           
         if self.configuration =='B':
             if self.init_method=='zero':  
                 self.weights =tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2, self.n_classes]))
             elif self.init_method=='norm':
                   self.weights = { '1': tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes])),'2': tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))} 
         if self.configuration =='R':
             if self.init_method=='zero':  
                 self.weights = tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))     
             elif self.init_method=='norm':
                   self.weights = tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)], self.n_classes]))
      
     def attention_weight_init(self,num):
         if num==0:
             self.attention_weights=[tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*4,self.n_hidden[(len(self.n_hidden)-1)]*2]))]
             self.sm_attention_weights=[tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2,self.n_hidden[(len(self.n_hidden)-1)]*2]))]
         if num>0:
             self.attention_weights.append(tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*4,self.n_hidden[(len(self.n_hidden)-1)]*2])))
             self.sm_attention_weights.append(tf.Variable(tf.random_normal([self.n_hidden[(len(self.n_hidden)-1)]*2,self.n_hidden[(len(self.n_hidden)-1)]*2])))
     def create(self):
       
       tf.reset_default_graph()
       self.weight_bias_init()
       self.x_ph = tf.placeholder("float32", [1, self.batch.shape[0], self.batch.shape[1]])
       self.y_ph = tf.placeholder("float32", self.batch_targ.shape)
       self.seq=tf.constant(self.truncated,shape=[1])
       self.seq2=tf.constant(self.truncated,shape=[1]) 
       self.dropout_ph = tf.placeholder("float32")
       self.fw_cell=self.cell_create('1')
       self.fw_cell2=self.cell_create('2')
       if self.configuration=='R':
           self.outputs, self.states= tf.nn.dynamic_rnn(self.fw_cell, self.x_ph,
                                             sequence_length=self.seq,dtype=tf.float32)
           if self.attention_number >0:
               self.outputs_zero_padded=tf.pad(self.outputs,[[0,0],[self.attention_number,0],[0,0]])
               self.RNNout1=tf.stack([tf.reshape(self.outputs_zero_padded[:,g:g+(self.attention_number+1)],[self.n_hidden[(len(self.n_hidden)-1)]*((self.attention_number)+1)]) for g in range(self.batch_size)])
               self.presoft=tf.matmul(self.RNNout1, self.weights) + self.biases
           else: 
               self.presoft=tf.matmul(self.outputs[0][0], self.weights) + self.biases
       elif self.configuration=='B':
           self.bw_cell=self.cell_create('1')
           self.bw_cell2=self.cell_create('2')
           with tf.variable_scope('1'):
               self.outputs, self.states= tf.nn.bidirectional_dynamic_rnn(self.fw_cell, self.bw_cell, self.x_ph,
                                             sequence_length=self.seq,dtype=tf.float32)
                                              
           self.first_out=tf.concat((self.outputs[0],self.outputs[1]),2)
           with tf.variable_scope('2'):
               self.outputs2, self.states2= tf.nn.bidirectional_dynamic_rnn(self.fw_cell2, self.bw_cell2, self.first_out,
                                                 sequence_length=self.seq2,dtype=tf.float32)
           self.second_out=tf.concat((self.outputs2[0],self.outputs2[1]),2)
            
           for i in range((self.attention_number*2)+1):
               self.attention_weight_init(i)
                
            
       
           self.zero_pad_second_out=tf.pad(tf.squeeze(self.second_out),[[self.attention_number,self.attention_number],[0,0]])
#               self.attention_chunks.append(self.zero_pad_second_out[j:j+attention_number*2])
           self.attention_m=[tf.tanh(tf.matmul(tf.concat((self.zero_pad_second_out[j:j+self.batch_size],tf.squeeze(self.first_out)),1),self.attention_weights[j])) for j in range((self.attention_number*2)+1)]
           self.attention_s=tf.nn.softmax(tf.stack([tf.matmul(self.attention_m[i],self.sm_attention_weights[i]) for i in range(self.attention_number*2+1)]),0)
           self.attention_z=tf.reduce_sum([self.attention_s[i]*self.zero_pad_second_out[i:self.batch_size+i] for i in range(self.attention_number*2+1)],0)
           self.presoft=tf.matmul(self.attention_z,self.weights)+self.biases
       if  self.output_act=='softmax':   
           self.pred=tf.nn.softmax(self.presoft)
           self.cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=self.presoft, labels=self.y_ph))
       elif self.output_act=='sigmoid':
           self.pred=tf.nn.sigmoid(self.presoft)
           self.cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=self.presoft, labels=self.y_ph))
       if self.optimizer == 'GD':
             self.optimize = tf.train.GradientDescentOptimizer(learning_rate=self.learning_rate).minimize(self.cost)
       elif self.optimizer == 'Adam':
             self.optimize = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.cost) 
       elif self.optimizer == 'RMS':
             self.optimize = tf.train.RMSPropOptimizer(learning_rate=self.learning_rate).minimize(self.cost) 
       self.correct_pred = tf.equal(tf.argmax(self.pred,1), tf.argmax(self.y_ph,1))
       self.accuracy = tf.reduce_mean(tf.cast(self.correct_pred, tf.float32))
       self.init = tf.global_variables_initializer()
       self.saver = tf.train.Saver()
       self.saver_var = tf.train.Saver(tf.trainable_variables())
       if self.save_location==[]:
           self.save_location=os.getcwd()
            
        
     def locations_create(self,size):
         self.locations=range(size)
         self.dif=size%self.batch_size
         if self.dif>0:
             for i in range(self.batch_size-self.dif):
                 self.locations=np.append(self.locations,0)
         self.location_new=np.reshape(self.locations,[-1,self.batch_size])     
         return self.location_new
 
       
     def implement(self,data):
         with tf.Session() as sess:
             self.saver.restore(sess, self.save_location+'/'+self.filename)
             self.test_out=[];
             for i in range(len(data)):
                 self.test_len=len(data[i])
                 self.test_locations=self.locations_create(self.test_len)
                 for k in range(len(self.test_locations)):
                    for j in range(self.batch_size):
                        self.batch[j]=data[i][self.test_locations[k,j]]
                    if k == 0:
                        self.test_out.append(sess.run(self.pred, feed_dict={self.x_ph: np.expand_dims(self.batch,0),self.dropout_ph:1}))                                    
                    elif k > 0:
                        self.test_out_2=sess.run(self.pred, feed_dict={self.x_ph: np.expand_dims(self.batch,0),self.dropout_ph:1})
                        self.test_out[i]=np.concatenate((self.test_out[i],self.test_out_2),axis=0)
                 self.test_out[i]=self.test_out[i][:self.test_len]
                  
         return self.test_out
                
def system_restore(data,save_path):
    ins=['Kick','Snare','Hihat']
    out=[]
    for i in ins:
        if i =='Kick':
            NN=SA([],np.zeros((1,1024)),np.zeros((1,1,2)),mini_batch_locations=np.zeros([1,1000]),network_save_filename=i+'ADTLibAll',save_location=save_path+"/files",cell_type='LSTMP',attention_number=2,n_hidden=[20,20],n_classes=2,truncated=1000,configuration='B',optimizer='GD')
            NN.create()
        NN.filename=i+'ADTLibAll'    
        out.append(NN.implement([data])[0])

    return out      
 

# -*- coding: utf-8 -*- Created on Fri May 26 15:10:50 2017  @author: CarlSouthall #               self.attention_chunks.append(self.zero_pad_second_out[j:j+attention_number*2])