Changeset 208

Timestamp:

09/23/08 16:06:27 (4 months ago)

Author:

pierre

Message:

Put also all the IO stuff for reading/writing analog signals into the io.py file. Need to developp the tools for such analog signals

Files:

• branches/cleanup/src/io.py (modified) (6 diffs)
• branches/cleanup/src/signals.py (modified) (9 diffs)

branches/cleanup/src/io.py

@@ -1 +1 @@
-import numpy, os, logging, cPickle
-DEFAULT_BUFFER_SIZE = 10000
+
+try:
+    import pytable
+    ENABLE_HDF5 = True
+except ImportError:
+    ENABLE_HDF5 = False
+
-
-
@@ -11 +18 @@
-    def __init__(self, filename):
-        self.filename = filename
-        if not os.path.exists(filename):
-            raise Exception("The file %s does not exists !" %filename)
-    
-    
-    ### Function to load/save data with the pickle package. Much more faster than a simple
-    ### plain text file. Useful if you don't care about reading the spike files
-    def pickle_load(self):
+        """
+        Try to load a binary format
+        """
-        return cPickle.load(file(self.filename,"r"))
-    
-    def pickle_write(self, object, filename):
+        """
+        Dump an object to a binary format
+        """
-        return cPickle.dump(object, file(filename, "w"))
-    
@@ -26 +36 @@
-    ### Function to load/save data in a text format.
-    def txt_load(self, sepchar = "\t", skipchar = "#"):
+        """
+        Load a text file and returns a list of data
+        """
-        myfile = open(self.filename, "r", DEFAULT_BUFFER_SIZE)
-        contents = myfile.readlines()
@@ -46 +59 @@
-
-class SpikeListIO(object):
+    """
+    Convenient object to load txt file and process them in order
+    to get a SpikeList object
+    """
+    def __init__(self, filename):
+        self.filename = filename
+        self.data_io  = DataIO(self.filename)
+        self.header   = {}
+    
+    def parse_header(self):
+        """
+        Read the informations that may be contained in the header of
+        the SpikeList object, if saved in a text file
+        """
+        f      = open(self.filename, 'r')
+        line   = f.readline()
+        while line[0] == '#':
+            key, value = line[1:].strip().replace(" ","").split("=")
+            if key == "dimensions":
+                value = value.split(" ")
+                try:
+                    value.remove('')
+                except Exception:
+                    pass
+                for idx in xrange(len(value)):
+                    value[idx] = eval(value[idx])
+                self.header[key] = value
+            else:
+                self.header[key] = eval(value)
+            line = f.readline()
+        f.close()
+    
+    def write_header(self, spikelist, filename):
+        """
+        Write the header of a SpikeList object into a file
+        """
+        f = open(filename,"w")
+        f.write("# dimensions = %s\n" % spikelist.dimensions)
+        f.write("# first_id = %d\n" % numpy.min(spikelist.id_list+1))
+        f.write("# last_id = %d\n" % numpy.max(spikelist.id_list+1))
+        f.write("# dt = %g\n" % spikelist.dt)
+        f.close()
+        
+    
+    def get_spikelist(self, id_list=None, dt=None, t_start=None, t_stop=None, dims=None):
+        """
+        Return the SpikeList object created after reading the file. Extra parameters may
+        be used to define the header, if informations are not available in the file
+        """
+        # First, we try to see if the data are stored in a pickled way (MUCH FASTER)
+        try :
+            res = self.data_io.pickle_load()
+            return res
+        except Exception:
+        # Otherwise we try the text mode....
+            self.parse_header()
+            if dt is None and 'dt' in self.header:
+                logging.debug("dt is infered from the file header")
+                dt = self.header['dt']
+            if id_list is None:
+                if ('first_id' in self.header) and ('last_id' in self.header):
+                    logging.debug("id_list is infered from the file header")
+                    n_cells = int(self.header['last_id']) - int(self.header['first_id']) + 1
+                    id_list = n_cells
+                else:
+                    raise Exception("id_list not provided and cannot be inferred from file header.")
+            if dims is None and 'dimensions' in self.header:
+                dims = self.header['dimensions']
+            if isinstance(id_list, int): # allows to just specify the number of neurons
+                id_list = range(id_list)
+            from NeuroTools import signals
+            return signals.SpikeList(self.data_io.txt_load(), id_list, dt, t_start, t_stop, dims)
+
+    def save_spikelist_pickle(self, spikelist, filename):
+        """
+        Save the SpikeList object into a binary format
+        """
+        self.data_io.pickle_write(spikelist, filename)
+    
+    def save_spikelist_txt(self, spikelist, filename):
+        """
+        Save the SpikeList into a text format
+        """
+        self.write_header(spikelist, filename)
+        data = numpy.array(spikelist.convert(format="[times, ids]"))
+        data = data.reshape(data.shape[1],data.shape[0])
+        self.data_io.txt_write(data, filename+".tmp")
+        os.system("cat %s >> %s" %(filename+".tmp", filename))
+        os.system("rm %s" %(filename+".tmp"))
+
+
+class AnalogSignalIO(object):
-    """
-    Convenient object to load txt file and process them in order
@@ -73 +178 @@
-            line = f.readline()
-        f.close()
-
-spikelist
+
+analogsignal
-        f = open(filename,"w")
-
-
-
-
-
+
+
+
+
+
+
+
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        self.data_io.txt_write(data, filename+".tmp")
-        os.system("cat %s >> %s" %(filename+".tmp", filename))
-        os.system("rm %s" %(filename+".tmp"))
-
-#class HDF5DataLoader(object):
-#class HDF5SpikeListLoader(object):
-
-
-
-class AnalogSignalIO(object):
-    """
-    Convenient object to load txt file and process them in order
-    to get a SpikeList object
-    """
-    def __init__(self, filename, signal_type):
-        self.filename = filename
-        self.loader   = TxtDataLoader(self.filename)
-    
-    def parse_header(self):
-        cmd = ''
-        f   = open(self.filename, 'r')
-        for line in f.readlines():
-            if line[0] == '#':
-                cmd += line[1:].strip() + ';'
-        f.close()
-        header = {}
-        exec cmd in None, header
-        return header
-
-    def get_dims(self, header):
-        return 0
-    
-    def get_AnalogSignal(self, id_list=None, dt=None, t_start=None, t_stop=None, dims=None, label=None):
-        header = self.parse_header()
-        
-        if dt is None and 'dt' in header:
-            logging.debug("dt is infered from the file header")
-            dt = header['dt']
-
-        if (id_list is None) and (('first_id' in header) and ('last_id' in header)):
-            logging.debug("id_list is infered from the file header")
-            n_cells = int(header['last_id']) - int(header['first_id']) + 1
-            id_list = n_cells
-        else:
-            raise Exception("id_list not provided and cannot be inferred from file header.")
-    
-        if dims is None and 'dimensions' in header:
-            dims = self.get_dims(header['dimensions'])
-        
-        if label is None:
-            label = self.loader.filename
-
-        if isinstance(id_list, int): # allows to just specify the number of neurons
-            id_list = range(id_list)
-
-        from NeuroTools import signals
-        return signals.SpikeList(self.loader.readData(), id_list, dt, t_start, t_stop, dims, label)
-
-
-
-##############################################
-### WORK IN PROGRESS
@@ -184 +262 @@
-
-
-def load_conductancetracelist(filename, id_list, dt = None, t_start=None, t_stop=None):
-    if isinstance(id_list,int): # allows to just specify the number of neurons
-        id_list = range(id_list)
-    analog_signals = readFile(filename)
-    return ConductanceTraceList(analog_signals, id_list, dt, t_start, t_stop)
-
-
-def load_membranetracelist(filename, id_list, dt = None, t_start=None, t_stop=None):
-    if isinstance(id_list,int): # allows to just specify the number of neurons
-        id_list = range(id_list)
-    analog_signals = readFile(filename)
-    return MembraneTraceList(analog_signals, id_list, dt, t_start, t_stop)
-
-
-def load_currenttracelist(filename, id_list, dt = None, t_start=None, t_stop=None):
-    if isinstance(id_list,int): # allows to just specify the number of neurons
-        id_list = range(id_list)
-    analog_signals = readFile(filename)
-    return CurrentTraceList(analog_signals, id_list, dt, t_start, t_stop)

branches/cleanup/src/signals.py

@@ -10 +10 @@
-try :
-    import pylab
-
+    
-except ImportError:
-
-
+
+
+
+
+
+
-
-
@@ -331 +335 @@
-        subplot = self.__getdisplay__(display)
-        if not subplot or not ENABLE_PLOTS:
-"Plots are unfortunately disabled... Please install matplotlib"
+MATPLOTLIB_ERROR
-            return
-        else:
@@ -574 +578 @@
-    ## Constructor and key methods to manipulate the SpikeList objects   ##
-    #######################################################################
-, label=''
+
-        """
-        Constructor of the SpikeList object
@@ -585 +589 @@
-        self.t_stop  = t_stop
-        self.dt      = dt
-        self.label   = label
-        self.dimensions  = dims
-        self.N           = len(id_list)
@@ -1386 +1389 @@
-
-        if not subplot or not ENABLE_PLOTS:
-"Plots are unfortunately disabled... Please install matplotlib"
+MATPLOTLIB_ERROR
-        else:
-            ids, spike_times = spk.convert(format="[ids, times]")
@@ -1418 +1421 @@
-                              (2, nb_cells) with the x (first line) and y (second line) coordinates of
-                              the cells
+            bounds          - The common color bounds used during all the movies frame. This is a tuple
+                              of values (min, max), in spikes per frame.
-            display         - if True, a new figure is created. Could also be a subplot. The averaged
-                              spike_histogram over the whole population is then plotted
@@ -1427 +1432 @@
-        
-        Examples:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    ####################################################################
@@ -1587 +1595 @@
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    """
-    Returns a SpikeList object from a file. If the file has been generated by PyNN, 
@@ -1608 +1924 @@
-    """
-    spike_loader = io.SpikeListIO(filename)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    """
-
-
-
-
+
+
+
+
+
+
-    Inputs:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-