示例#1
0
def sftfOP(datapath, logpath, syncpath, savepath, showflag, subX=None, subY=None):
    '''SF X TF stimulus analysis for Optical Imaging'''    
    '''load data and stimulus information'''    
    print "loading traces from:", datapath    
    #celltraces = loadh5(datapath, 'data_t')
    celltraces = loadtraces(datapath)
    
    print "loading stimulus log from:",logpath 
    (stimuluscondition, sweeplength, _) = getSweepTimesOP(logpath, 'sftf')
    sweeplength = int((sweeplength/60)*4)
    '''stimuluscondition to synccondition'''
    syncc = getsync(syncpath, stimuluscondition)
    
    '''select appropriate subset of sweeps'''
    if subX is None:
        subX = stimuluscondition[0,2]
    if subY is None:
        subY = stimuluscondition[0,3]
    print "subX: ", subX
    print "subY: ", subY

    ang = stimuluscondition[np.nonzero(stimuluscondition[:,4]),4]
    dang = amin(ang)
    
    temp=[]
    temp = np.where(np.logical_and(syncc[:,2]==subX, syncc[:,3]==subY))
    syncsubtemp = syncc[temp[0][:]]
    '''stimuli with stimulus in position (subX, subY)'''
    temp2 = np.where(np.logical_not(mod(syncsubtemp[:,4], dang)))
    syncsub = syncsubtemp[temp2[0][:]]
    '''only conditions with grating - not the inter-sweep interval'''
    
    nc = len(celltraces)
    print "Number of Cells:", nc
    
    '''tuning for each orientation'''
    orivals = np.unique(syncsub[:,4])
    if len(orivals)>3:
        orivals = np.delete(orivals, 3, 0)
    f0mean = np.zeros((3,3,nc,3))
    f0sem = np.zeros((3,3,nc,3))
    for i in range(len(orivals)):
        synccondition = syncsub[np.where(syncsub[:,4] == orivals[i])]       
        ostr = str(int(orivals[i]))
        (f0m, f0s) = sftfOPtuning(synccondition, celltraces, sweeplength, showflag)
        f0mean[:,:,:,i] = f0m
        f0sem[:,:,:,i] = f0s
    
    newpath = os.path.join(savepath, 'SFTFData')
    if os.path.isdir(newpath) == False:
        os.mkdir(newpath)
    elif os.path.exists(newpath) == True:
        print "folder already exists"
    
    '''make figures'''
    for s in range(int(ceil(nc/4))+1):
        firstcell = (s*4)
        lastcell = firstcell+3
        figure(s)
        for c in range(4):
            sp = firstcell + c
            if sp < nc:
                for ci in range(3):                    
                    subplot(4,4,(3*c)+1+ci)
                    #set_xscale('log')
                    #set_yscale('log')
                    imshow(f0mean[:,:,sp,ci], origin='lower',cmap='gray')
                    text(0,0, str(sp+1), fontsize=7, color='white')
                    xlabel('TF (Cyc/Sec)', fontsize=10)
                    ylabel('SF (Cyc/Deg)', fontsize=10)
                    xticks(range(3), ['1', '4', '15'])
                    yticks(range(3), ['0.05','0.1','0.2'])
                    tick_params(axis='both', which='major', labelsize=7)
                    tight_layout()                
                    cbar = colorbar()
                    cbar.ax.set_ylabel('Mean dF/F', fontsize=8)
                    for t in cbar.ax.get_yticklabels():
                        t.set_fontsize(8)
            subplots_adjust(top=0.9)
        suptitle("Cells "+ str(firstcell+1) + " to " + str(lastcell+1), fontsize=14)
        figtext(0.2, 0.92,'0 Deg')
        figtext(0.5, 0.92, '120 Deg')
        figtext(0.8, 0.92, '240 Deg')
        filename = 'sftf_tuning' + str(s) + '.png'            
        fullfilename = os.path.join(newpath, filename) 
        savefig(fullfilename)
        if showflag:            
            show(False)
    
    '''save data'''    
#    saveh5(savepath, 'sftf_f0mean.h5', f0mean)
#    saveh5(savepath, 'sftf_f0sem.h5', f0sem)
    fullfilename = os.path.join(newpath, "sftfData.h5")
    f = h5py.File(fullfilename, 'w')
    dset = f.create_dataset("f0mean", f0mean.shape, 'f')
    dset[...] = f0mean
    dset.attrs["mask"] = (subX, subY)
    dset.attrs["orivalues"] = orivals
    dset.attrs["datapath"] = datapath
    dset.attrs["logpath"] = logpath
    dset.attrs["syncpath"] = syncpath
    dset2 = f.create_dataset("f0sem", f0sem.shape, 'f')
    dset2[...]=f0sem
    f.close()

    return(f0mean, f0sem, syncc)
示例#2
0
def gratingOP(datapath, logpath, syncpath, savepath, modality, showflag, subX=None, subY=None):
    '''grating analysis for ori, sf, tf grating stimulus for Optical Imaging'''
    '''modality must be either: 'ori', 'sf', 'tf' '''
    
    '''load data and stimulus information'''    
    print "loading traces from:", datapath    
    celltraces = loadh5(datapath, 'data_t')
    #celltraces = loadtraces(datapath)
    
    print "loading stimulus log from:",logpath 
    (stimuluscondition, sweeplength, constring) = getSweepTimesOP(logpath, modality)
    print constring
    sweeplength = int((sweeplength/60)*4)
    '''stimuluscondition to synccondition'''
    syncc = getsync(syncpath, stimuluscondition)
    
    '''get appropriate subset of stimuli'''
    if subX is None:
        subX = stimuluscondition[0,2]
    if subY is None:
        subY = stimuluscondition[0,3]
    print "subX: ", subX
    print "subY: ", subY

    '''finds the minimum angle size - but not 0 or 1'''    
    ang = stimuluscondition[np.nonzero(stimuluscondition[:,4]),4]
    ang = ang[np.where(ang>1)]
    dang = amin(ang)
    
    '''stimuli with stimulus in position (subX, subY)'''
    temp=[]
    temp = np.where(np.logical_and(syncc[:,2]==subX, syncc[:,3]==subY))
    syncsubtemp = syncc[temp[0][:]]
    '''only conditions with grating - not the inter-sweep interval'''
    gratingsweeps = np.where(np.logical_not(mod(syncsubtemp[:,4], dang)))
    syncsub = syncsubtemp[gratingsweeps[0][:]]
    '''only the inter-sweep intervals''' 
    intersweeps = np.where(mod(syncsubtemp[:,4], dang))
    syncinter = syncsubtemp[intersweeps[0][:]]  
    
    nc = len(celltraces)
    print "Number of Cells:", nc
    tfreq = 3.0
    
    if (modality.find("sf")+1):
        tlabel = "Spatial frequency (Cyc/Deg)"
        ticks = np.arange(0, 0.62, 0.1)
        print tlabel
        print constring
        sortc = 5
        orivals = np.unique(syncsub[:,4])
        if len(orivals)>3:
            orivals = np.delete(orivals, 3, 0)
        for i in range(len(orivals)):
            synccondition = syncsub[np.where(syncsub[:,4] == orivals[i])]          
            print str(orivals[i])+"Deg" 
            (tuning, f0m, f0s) = dotuningOP(synccondition, celltraces, sortc, sweeplength, showflag)
            if i == 0:
                f0mean = np.empty((size(f0m,0), size(f0m,1), len(orivals)))
                f0sem = np.empty((size(f0m,0), size(f0m,1), len(orivals)))
            f0mean[:,:,i] = f0m[:,:]
            f0sem[:,:,i] = f0s[:,:]                
    elif (modality.find("tf")+1):
        tlabel = "Temporal frequency (Cyc/Sec)"
        ticks = range(0,16,3)
        print tlabel
        print constring
        sortc = 6
        orivals = np.unique(syncsub[:,4])
        if len(orivals)>3:
            orivals = np.delete(orivals, 3, 0)
        for i in range(len(orivals)):
            synccondition = syncsub[np.where(syncsub[:,4] == orivals[i])]             
            print str(orivals[i])+"Deg" 
            (tuning, f0m, f0s) = dotuningOP(synccondition, celltraces, sortc, sweeplength, showflag)
            if i == 0:
                f0mean = np.empty((size(f0m,0), size(f0m,1), len(orivals)))
                f0sem = np.empty((size(f0m,0), size(f0m,1), len(orivals)))
            f0mean[:,:,i] = f0m[:,:]
            f0sem[:,:,i] = f0s[:,:]            
    elif (modality.find("ori")+1):
        tlabel = "Orientation (Deg)"
        ticks = range(0,361,90)
        print tlabel
        print constring
        sortc = 4
        synccondition = syncsub
        (tuning, f0mean, f0sem) = dotuningOP(synccondition, celltraces, sortc, sweeplength, showflag)
        ( _ , imean, isem) = dotuningOP(syncinter, celltraces, sortc, sweeplength, showflag)
#        if len(imean) < len(f0mean):
#            tin = np.zeros((1,size(imean,1)))
#            imean = insert(imean, len(imean), tin, 0)
#            isem = insert(isem, len(isem), tin, 0)
    else:
        print "No modality specified"
        
    newpath = os.path.join(savepath, 'Data')
    if os.path.exists(newpath) == False:
        os.mkdir(newpath)
    else:
        print "folder already exists"
        
    '''plot data'''
    for s in range(int(ceil(nc/9))+1):
        firstcell = (s*9)
        lastcell = firstcell+8
        figure(s)
        for c in range(9):
            sp = firstcell + c
            if sp<nc:
                ax1 = subplot(3, 3, c+1)
                if (modality.find("sf")+1) or (modality.find("tf")+1):
#                    ax1.set_xscale('log')
                    ax1.errorbar(tuning, f0mean[:,sp,0], yerr=f0sem[:,sp,0], fmt = 'ro', capsize=2, linestyle='-')
                    ax1.errorbar(tuning, f0mean[:,sp,1], yerr=f0sem[:,sp,1], fmt = 'bo', capsize=2, linestyle='-')
                    ax1.errorbar(tuning, f0mean[:,sp,2], yerr=f0sem[:,sp,2], fmt = 'go', capsize=2, linestyle='-')
                else:
                    ax1.errorbar(tuning, f0mean[:,sp], yerr=f0sem[:,sp], fmt = 'ro', capsize=2, linestyle='-')
                    ax1.errorbar(tuning, imean[:,sp], yerr=isem[:,sp], fmt = 'ko', capsize=2, linestyle='-')
                ax1.set_ylabel('Mean DF/F', fontsize=10)
                ax1.set_ylim(bottom=0)
                xlabel(tlabel, fontsize=10)
                xticks(ticks)             
                text(0,0, str(sp+1), fontsize=10)
                tick_params(axis='both', which='major', labelsize=7)
            tight_layout()
        subplots_adjust(top=0.9)
        suptitle(constring + " Cells "+ str(firstcell+1) + " to " + str(lastcell+1), fontsize=14)
        if (modality.find("sf")+1) or (modality.find("tf")+1):
            figtext(0.1, 0.92, '0 Deg', color='red')
            figtext(0.2, 0.92, '120 Deg', color = 'blue')
            figtext(0.3, 0.92, '240 Deg', color = 'green')            
        filename = modality + '_tuning'+str(s)+'.png'
        fullfilename = os.path.join(newpath, filename) 
        savefig(fullfilename)
        if showflag:            
            show(False)
    
    '''save data'''
    filename = modality + "Data.h5"    
    fullfilename = os.path.join(newpath, filename)
    f = h5py.File(fullfilename, 'w')
    dset = f.create_dataset("f0mean", f0mean.shape, 'f')
    dset[...] = f0mean
    dset.attrs["mask"] = (subX, subY)    
    if (modality.find("sf")+1) or (modality.find("tf")+1):     
        dset.attrs["orivalues"] = orivals
    dset.attrs["datapath"] = datapath
    dset.attrs["logpath"] = logpath
    dset.attrs["syncpath"] = syncpath
    dset2 = f.create_dataset("f0sem", f0sem.shape, 'f')
    dset2[...] = f0sem
    dset3 = f.create_dataset("tuning", tuning.shape, 'f')
    dset3[...] = tuning
    dset4 = f.create_dataset("synccondition", syncc.shape, 'f')
    dset4[...] = syncc
    dset5 = f.create_dataset("imean", imean.shape, 'f')
    dset5[...] = imean
    dset6 = f.create_dataset("isem", isem.shape, 'f')
    dset6[...] = isem
    f.close()    
    
    return (tuning, f0mean, f0sem, syncc)
示例#3
0
def gratingOP(matpath, logpath, syncpath, modality, showflag, subX, subY):
    print "loading traces from:", matpath    
    celltraces = loadtraces(matpath)
    
    print "loading stimulus log from:",logpath 
    (stimuluscondition, sweeplength) = getSweepTimesOP(logpath, modality)
    sweeplength = int((sweeplength/60)*4)
    print "sweeplength:", sweeplength
    '''stimuluscondition to synccondition'''
    syncc = getsync(syncpath, stimuluscondition)
    
    temp=[]
    temp = np.where(np.logical_and(syncc[:,2]==subX, syncc[:,3]==subY))
    syncsub = syncc[temp[0][:]]
    
    nc = len(celltraces)
    tfreq = 3.0
    
#    if (modality.find("sf")+1):
#        tlabel = "Spatial frequency (Cyc/Deg)"
#        ticks = np.arange(0, 0.62, 0.1)
#        print tlabel
#        #print constring
#        orivals = np.unique(stimc[:,1])
#        orivals = np.delete(orivals, 3, 0)
#        for i in range(len(orivals)):
#            stimuluscondition = stimc[np.where(stimc[:,1] == orivals[i])]
#            ostr = str(orivals[i])+"Deg"            
#            constring = constring + " at " + ostr
#            print ostr
#            (tuning, f0mean, f0sem, f1mean, f1sem, f2mean, f2sem) = dotuning(stimuluscondition, spiketimes, cellnumber, 2, duration, tlabel, ticks, constring, ostr, showflag)                
#    elif (modality.find("tf")+1):
#        tlabel = "Temporal frequency (Cyc/Sec)"
#        ticks = range(0,15,3)
#        print tlabel
#        #print constring
#        orivals = np.unique(stimc[:,1])
#        orivals = np.delete(orivals, 3, 0)
#        for i in range(len(orivals)):
#            ostr = str(orivals[i])+"Deg"
#            constring = constring + " at " + ostr
#            stimuluscondition = stimc[np.where(stimc[:,1] == orivals[i])]
#            print ostr
#            (tuning, f0mean, f0sem, f1mean, f1sem, f2mean, f2sem) = dotuning(stimuluscondition, spiketimes, cellnumber, 3, duration, tlabel, ticks, constring, ostr, showflag)
    if (modality.find("ori")+1):
        tlabel = "Orientation (Deg)"
        ticks = range(0,361,90)
        #print tlabel
        #print constring
        synccondition = syncsub
        ostr = "allori"
        (tuning, f0mean, f0sem) = dotuningOP(synccondition, celltraces, sweeplength, tlabel, ticks, ostr, showflag)
    else:
        print "No modality specified"
        
    '''plot data'''
    if showflag:    
        for s in range(int(ceil(nc/9))):
            firstcell = (s*9)
            lastcell = firstcell+8
            figure(s)
            for c in range(9):
                sp = firstcell + c
                if sp<nc:
                    ax1 = subplot(3, 3, c+1)
                    ax1.errorbar(tuning, f0mean[:,sp], yerr=f0sem[:,sp], fmt = 'ro', capsize=2, linestyle='-')
                    ax1.set_ylabel('Mean', color='r', fontsize=10)
                    ax1.set_ylim(bottom=0)
                    for tl in ax1.get_yticklabels():
                        tl.set_color('r')
                    xlabel(tlabel, fontsize=10)
                    #if (modality.find("sf")+1) or (modality.find("tf")+1):
                        #ax1.set_xscale('log')
                        #ax2.set_xscale('log')
                    xticks(ticks)             
                    text(0,0, str(sp+1), fontsize=10)
                    tick_params(axis='both', which='major', labelsize=7)
                tight_layout()
            subplots_adjust(top=0.9)
            suptitle("Cells "+ str(firstcell+1) + " to " + str(lastcell+1), fontsize=14)
            fname = matpath+'_'+ostr+'_tuning'+str(s)+'.png'
            savefig(fname)
            show()
    return (tuning, f0mean, f0sem)
    
    '''save data'''    
示例#4
0
def PSTmovie(datapath, logpath, syncpath, modality, moviename, subX=None, subY=None):
    '''load stimulus log'''
    print "loading stimulus log from:",logpath    
    (stimuluscondition, sweeplength, _) = getSweepTimesOP(logpath, modality)
    sweeplength = (sweeplength/60)*4
    '''stimuluscondition is sorted on xp, yp and sortcondition'''
    
    '''load h5 movie'''
    print "loading data from:",datapath    
#    f = h5py.File(datapath, 'r')
#    print f.keys()
#    d = f['data']
#    data = d[...]
    data = loadh5(datapath, 'data')
    
    sz0 = size(data,0) #time dimension
    sz1 = size(data,1) #x dimension
    sz2 = size(data,2) #y dimension
    
    data = np.swapaxes(data,0,2)
    data = np.swapaxes(data,0,1)
    
    '''stimuluscondition to synccondition'''
    synccondition = getsync(syncpath, stimuluscondition)
    
    if subX is None:
        subX = stimuluscondition[0,2]
    if subY is None:
        subY = stimuluscondition[0,3]
    print "subX: ", subX
    print "subY: ", subY
    
    '''select specific (subX, subY) region'''
    temp = []
    temp = np.where(np.logical_and(synccondition[:,2]==subX, synccondition[:,3]==subY))
    syncsub = synccondition[temp[0][:]]
    
    '''average same conditions together'''
    valuedifference = np.ediff1d(syncsub[:,4], to_end=None, to_begin = 1)
    transitions = argwhere(valuedifference)
    transitions = append(transitions, len(valuedifference))
    
    conditions = np.zeros(((len(transitions)-1),1))
    temp = np.zeros((sz1, sz2, sweeplength))
    moviecon = []
    contemp = np.empty((sweeplength,1))
    
    for t in range(len(conditions)):
        conditions[t] = syncsub[transitions[t],4]
    for cond in range(len(conditions)):    
        firstpoint = transitions[cond]
        lastpoint = transitions[cond+1]
        for i in range(firstpoint, lastpoint):
            temp = temp + data[:,:,syncsub[i,0]:(syncsub[i,0]+sweeplength)]
        temp /= (lastpoint-firstpoint+1)
        contemp[:] = conditions[cond]
        if cond == 0:
            movie = temp
        else:
            movie = append(movie, temp, axis=2)
        moviecon = append(moviecon, contemp)
       
    '''put in baselines??'''    
    
    
    '''make movie'''
    print "creating movie"     
    for i in range(size(movie,2)):
        plotmov(movie, moviecon, i)
        fname = '_tmp%05d.png'%i
        plt.savefig(fname)
        plt.clf()
 
    try: 
        os.system("del", moviename)
    except:
        print moviename + "not found, a new one will be created."

    os.system("ffmpeg -f image2 -i _tmp%05d.png " + moviename)
    os.system("del _tmp*.png")

    return (stimuluscondition, syncsub)