Source code for spykeutils.conversions

import scipy as sp
import neo

from . import SpykeException


[docs]def spike_train_to_spikes(spike_train, include_waveforms=True): """ Return a list of spikes for a spike train. Note that while the created spikes have references to the same segment and unit as the spike train, the relationships in the other direction are not automatically created (the spikes are not attached to the unit or segment). Other properties like annotations are not copied or referenced in the created spikes. :param spike_train: A spike train from which the :class:`neo.core.Spike` objects are constructed. :type spike_train: :class:`neo.core.SpikeTrain` :param bool include_waveforms: Determines if the ``waveforms`` property is converted to the spike waveforms. If ``waveforms`` is None, this parameter has no effect. :returns: A list of :class:`neo.core.Spike` objects, one for every spike in ``spike_train``. :rtype: list """ waves = None if include_waveforms: waves = spike_train.waveforms spikes = [] for i, t in enumerate(spike_train): s = neo.Spike(t, sampling_rate=spike_train.sampling_rate, left_sweep=spike_train.left_sweep) if waves is not None: s.waveform = waves[i, :, :] s.unit = spike_train.unit s.segment = spike_train.segment spikes.append(s) return spikes
[docs]def spikes_to_spike_train(spikes, include_waveforms=True): """ Return a spike train for a list of spikes. All spikes must have an identical left sweep, the same unit and the same segment, otherwise a ``SpykeException`` is raised. Note that while the created spike train has references to the same segment and unit as the spikes, the relationships in the other direction are not automatically created (the spike train is not attached to the unit or segment). Other properties like annotations are not copied or referenced in the created spike train. :param sequence spikes: A sequence of :class:`neo.core.Spike` objects from which the spike train is constructed. :param bool include_waveforms: Determines if the waveforms from the spike objects are used to fill the ``waveforms`` property of the resulting spike train. If ``True``, all spikes need a ``waveform`` property with the same shape or a ``SpykeException`` is raised (or the ``waveform`` property needs to be ``None`` for all spikes). :return: All elements of ``spikes`` as spike train. :rtype: :class:`neo.core.SpikeTrain` """ if not spikes: raise SpykeException('No spikes to create spike train!') tu = spikes[0].time.units times = sp.zeros(len(spikes)) * tu s = spikes[0].segment u = spikes[0].unit ls = spikes[0].left_sweep if include_waveforms and spikes[0].waveform is not None: sh = spikes[0].waveform.shape wu = spikes[0].waveform.units waves = sp.zeros((len(spikes), sh[0], sh[1])) * wu else: waves = None sh = None for i, spike in enumerate(spikes): if (u != spike.unit or s != spike.segment or ls != spike.left_sweep): raise SpykeException('Cannot create spike train from spikes with ' 'nonuniform properties!') times[i] = spikes[i].time if include_waveforms: if spike.waveform is None: if waves is not None: raise SpykeException('Cannot create spike train from ' 'spikes where some waveforms are ' 'None') elif sh != spike.waveform.shape: raise SpykeException('Cannot create spike train from spikes ' 'with nonuniform waveform shapes!') if waves is not None: waves[i, :, :] = spike.waveform ret = neo.SpikeTrain(times, t_start=times.min(), t_stop=times.max(), waveforms=waves, left_sweep=ls) ret.unit = u ret.segment = s ret.left_sweep = ls return ret
[docs]def analog_signal_array_to_analog_signals(signal_array): """ Return a list of analog signals for an analog signal array. If ``signal_array`` is attached to a recording channel group with exactly is many channels as there are channels in ``signal_array``, each created signal will be assigned the corresponding channel. If the attached recording channel group has only one recording channel, all created signals will be assigned to this channel. In all other cases, the created signal will not have a reference to a recording channel. Note that while the created signals may have references to a segment and channels, the relationships in the other direction are not automatically created (the signals are not attached to the recording channel or segment). Other properties like annotations are not copied or referenced in the created analog signals. :param signal_array: An analog signal array from which the :class:`neo.core.AnalogSignal` objects are constructed. :type signal_array: :class:`neo.core.AnalogSignalArray` :return: A list of analog signals, one for every channel in ``signal_array``. :rtype: list """ signals = [] rcg = signal_array.recordingchannelgroup for i in xrange(signal_array.shape[1]): s = neo.AnalogSignal( signal_array[:, i], t_start=signal_array.t_start, sampling_rate=signal_array.sampling_rate) if len(rcg.recordingchannels) == 1: s.recordingchannel = rcg.recordingchannels[0] elif len(rcg.recordingchannels) == signal_array.shape[1]: s.recordingchannel = rcg.recordingchannels[i] s.segment = signal_array.segment signals.append(s) return signals
[docs]def event_array_to_events(event_array): """ Return a list of events for an event array. Note that while the created events may have references to a segment, the relationships in the other direction are not automatically created (the events are not attached to the segment). Other properties like annotations are not copied or referenced in the created events. :param event_array: An event array from which the Event objects are constructed. :type event_array: :class:`neo.core.EventArray` :return: A list of events, one for of the events in ``event_array``. :rtype: list """ events = [] for i, t in enumerate(event_array.times): e = neo.Event( t, event_array.labels[i] if i < len(event_array.labels) else '') e.segment = event_array.segment events.append(e) return events
[docs]def epoch_array_to_epochs(epoch_array): """ Return a list of epochs for an epoch array. Note that while the created epochs may have references to a segment, the relationships in the other direction are not automatically created (the events are not attached to the segment). Other properties like annotations are not copied or referenced in the created epochs. :param epoch_array: A period array from which the Epoch objects are constructed. :type epoch_array: :class:`neo.core.EpochArray` :return: A list of events, one for of the events in ``epoch_array``. :rtype: list """ periods = [] for i, t in enumerate(epoch_array.times): p = neo.Epoch( t, epoch_array.durations[i], epoch_array.labels[i] if i < len(epoch_array.labels) else '') p.segment = epoch_array.segment periods.append(p) return periods