comparison utils.py @ 0:5609fd93e935

First commit.

+"""
+A utility module to assist cortical_model.py with general procedures, e.g., file reading and writing.
+
+Packaged dependencies:
+    * erb.dat
+    * outMidFir.dat
+    
+External dependencies:
+    * scipy
+    * numpy
+    * matplotlib
+"""
+
+import numpy as np
+import scipy.io.wavfile as wave
+import matplotlib.pyplot as plt
+import scipy.fftpack as fft
+
+def load_erb_data():
+	"""
+	Loads and returns 39 ERB frequencies and bandwidths
+    
+    Parameters:
+        NONE
+        
+    Returns:
+        * fc (type: numpy array of floats) - a vector of length 39 with elements containing
+            the centre frequencies of each ERB.
+        * bw (type: numpy array of floats) - a vector of length 39 with elements containing
+            the bandwidths of each ERB.
+    
+    Dependencies:
+        * erb.dat (place in the same folder as utils.pyc)
+	"""
+	# read our data from a text file
+	data=np.loadtxt("erb.dat",delimiter=",")
+
+	# load centre frequencies from the first column into fc
+	fc=np.array(data[:,0])
+	# load bandwidths from the second column into bw
+	bw=np.array(data[:,1])
+
+	return fc,bw
+
+def load_outMidFir_coeff():
+    """
+    Loads and returns 39 ERB frequencies and bandwidths
+        
+    Parameters:
+        NONE
+        
+    Returns:
+        * b (type: numpy array of floats) - a vector of length 4097 containing the impulse
+            response of the outer middle ear.
+        
+    Dependencies:
+        * outMidFir.dat (place in the same folder as utils.pyc)
+    """
+
+    b=np.loadtxt("outMidFir.dat", delimiter=",")
+
+    return b
+
+def exp_sequence(start, stop, n, base=2):
+    """
+    Creates a linear sequence with n points starting from start and ending at stop. For each
+    element in the sequence, e, the output sequence is 2^e, generating an exponential sequence
+    with base 2.
+    
+    Parameters:
+        * start (type: numerical int) - determines the first element of the sequence, i.e.,
+            base^start. (Required)
+        * stop (type: numerical int) - determines the last element of the sequence, i.e.,
+            base^stop. (Required)
+        * n (type = numerical int) - determines the number of elements in the sequence. (Required)
+        * base (type: numerical) - determines the exponential base. (Optional; Default = 2)
+    
+    Returns:
+        * seq - the exponential sequence
+    """
+    
+    seq = [base**x for x in np.linspace(start,stop,n)]
+    
+    return seq
+
+def wavread(file):
+    """
+    Reads the audio data from a wav file and converts it to floating point ranging from -1 to 1.
+    
+    Parameters:
+        * file (type: string) - the name of the wav file to read from. (Required)
+        
+    Returns:
+        * fs (type: numerical) - the sampling frequency of the signal storied in file
+        * data (type: numpy array of floats) - the data of the signal stored in file normalised
+            to an amplitude range of -1 to 1.
+    """
+
+    fs,data = wave.read(file)
+    data = np.array(int16_to_nfloat(data))
+
+    return fs,data
+
+def wavwrite(file, fs, data, precision = 16):
+    """
+    Unnormalises the audio data to a specified integer precision and converts to an int, then 
+    writes the audio data to a wav file. (E.g., if 16-bit precision, then highest amplitude
+    is equal to 2^16).
+        
+    Parameters:
+        * file (type: string) - the name of the wav file to write to. (Required)
+        * fs (type: numerical) - the sampling frequency of the signal. (Required)
+        * data (type: array-like matrix of floats) - the signal data normalised from -1 to 1. The signal will be clipped if not
+        in this range. (Required)
+        * precision (type: numerical int)- the bit precision to store at. Can only be 16 or 32 bit, because that is
+        all scipy allows.
+        
+    Returns:
+        NONE
+        
+    TODO explore WAVE package to be allow for 24bit precision.
+    """
+    
+    data[data>1] = 1
+    data[data<-1] = -1
+    
+    if(precision == 16):
+        dtype = np.int16
+    elif(precision == 32):
+        dtype = np.int32
+    else:
+        print "Error: precision can only be 16 or 32 bit due to scipy package."
+        return
+
+    data = nfloat_to_int(data)
+    wave.write(file, fs, data)
+    
+    return
+
+def plot_fft(x, xscale = 'log', yscale = 'log', show = True):
+    """
+    Plots the fft of signal x. If the figure is not shown, the current plot is held to allow other plots to
+    be added to the same figure.
+    
+    Parameters:
+        * x (type: array-like matrix of floats) - the signal to be analysed. (Required)
+        * xscale (type: string) - the scale of the frequency axis. Values are 'log' or 'linear'. (Optional; Default = 'log')
+        * yscale (type: string) - the scale of the amplitude axis. Values are 'log' or 'linear'. (Optional; Default = 'log')
+        * show (type: boolean) - specifies whether the figure should be shown. If False, the current plot will be held so
+        other plots can be added to the figure. (Optional; Default = True)
+        
+    Returns:
+        NONE
+    """
+
+    if(xscale.lower() == "log"): plt.gca().set_xscale('log')
+    if(xscale.lower() == "log"): plt.gca().set_yscale('log')
+
+    fftx = np.absolute(fft.fft(x))
+    plt.plot(range(np.shape(x)[0]),fftx)
+    if(show):
+        plt.show()
+    else:
+        plt.hold(True)
+
+    return
+
+def int_to_nfloat(input, type=np.float32):
+    """
+    Convert integer with to floating point with a range from -1 to 1.
+        
+    Parameters:
+        * input (type: array-like matrix of ints) - a signed integer array. (Required)
+        dtype : the output datatype. (Optional; Default = np.float32)
+        
+    Returns:
+        * y (type: array-like matrix of floats) - a float array normalised to a
+            range of -1 to 1.
+    """
+    
+    input = np.array(input)
+    assert input.dtype.kind == 'i', "'input' must be an array-like matrix of integers."
+    type = np.dtype(type);
+    inputdtype = np.dtype(type(input[0]))
+    input = input.astype(type)
+    
+    input[input > 0] = input[input > 0] / np.iinfo(inputdtype).max
+    input[input < 0] = input[input < 0] / -np.iinfo(inputdtype).min
+    
+    y = input
+    return y
+
+def nfloat_to_int(input, type=np.int16):
+    """
+    Convert a float array with amplitude ranging from -1 to 1 to a unnormalised signed 
+    integer array with specified precision.
+        
+    Parameters:
+        * input (type: array-like matrix of floats) - a float array. (Required)
+        dtype : the output datatype (also determines the precision). 
+        (Optional; Default = np.int16)
+        
+    Returns:
+        * y (type: array-like matrix of ints) - an unnormalised to a
+        range of -1 to 1.
+    """
+    
+    input = np.array(input)
+    assert input.dtype.kind == 'f', "'input' must be an array of floats!"
+    
+    input[input > 0] = input[ input > 0 ] * np.iinfo(np.int16).max
+    input[input < 0] = input[ input < 0 ] * -np.iinfo(np.int16).min
+    
+    y = input.astype(type)
+    
+    return y