def saccEndPoints(dm): """ Analyzes and plots the saccade endpoints. Arguments: dm -- DataMatrix """ i = 1 newFig() l = [["Condition", "Luminance", "SaccDir", "End X (M)", "End X (SD)"]] for cond in ("constant", "swap", "onset"): for saccCol in ("white", "black"): _dm = dm.select('cond == "%s"' % cond).select('saccCol == "%s"' % saccCol) a = (_dm.select('saccSide == "left"')["saccEndX"] - 512) / pxPerDeg l.append([cond, saccCol, "left", a.mean(), a.std()]) a = (_dm.select('saccSide == "right"')["saccEndX"] - 512) / pxPerDeg l.append([cond, saccCol, "right", a.mean(), a.std()]) plt.subplot(3, 2, i) plt.xlim(0, 1024) plt.ylim(0, 768) plt.title("%s - %s" % (cond, saccCol)) plt.axvline(1024 / 2, linestyle=":", color="black") plt.axvline(1024 / 6, linestyle=":", color="black") plt.axvline(1024 - 1024 / 6, linestyle=":", color="black") plt.axhline(768 / 2, linestyle=":", color="black") plt.plot(_dm["saccEndX"], _dm["saccEndY"], ",", color=darkColor) if cond != "onset": plt.xticks([]) else: plt.xticks([0, 512, 1024]) if saccCol != "white": plt.yticks([]) else: plt.yticks([0, 384, 768]) i += 1 dm = DataMatrix(l) dm.sort(["SaccDir"]) dm.save("output/%s/saccEndPoints.csv" % exp) print dm saveFig("endPoints", show=True)
def descriptives(dm): l = [['pp', 'rt', 'resp', 'nchar', 'nfunc', 'chardur', 'funcdur']] for i in dm.range(): sn, full_resp, rt = dm['subject_nr'][i], dm['full_response'][i], \ dm['free_writing_time'][i] resp = dm['free_writing_result'][i].replace('Space', ' ') rt = rt / 1000. - (len(full_resp)+1)*1.185 nchar = len(full_resp) + 1 charDur = rt / (len(full_resp)+1) funcDur = rt / len(resp) nresp = len(resp) print(full_resp) print('%2d\t%s\t%.2f\t%d\t%d\t%.2f\t%.2f' % (sn, resp, rt, nchar, len(resp), charDur, funcDur)) l.append([sn, rt, resp, nchar, len(resp), charDur, funcDur]) dm = DataMatrix(l) dm.sort('pp') print(dm) dm.save('output/sentences.csv')
if __name__ == '__main__': l = [['img', 'xCogOrig', 'yCogOrig', 'xCogMatch', 'yCogMatch']] for obj in os.listdir(srcOb): #if not "paintbrush" in obj: # continue if "png" in obj or 'cog-correct' in obj: continue nob = "non-object_%s" % obj objPath = os.path.join(srcOb, obj) nobPath = os.path.join(srcNob, nob) print print 'Original %s' % objPath x, y = matchCog(objPath) print "COG original object = ", x #sys.exit() print 'Match %s' % nobPath _x, _y = matchCog(nobPath, xy=(x,y)) l.append([obj, x, y, _x, _y]) #plt.show() #break dm = DataMatrix(l) print dm dm.save('cogMatch.csv')
def prepFit(dm, suffix=''): """ Perform a linear-regression fit on only the first 220 ms. Arguments: dm -- DataMatrix Keyword arguments: suffix -- A suffix for the output files. (default='') """ fig = newFig(size=bigWide) plt.subplots_adjust(wspace=0, hspace=0) i = 0 l = [['subjectNr', 'sConst', 'iConst', 'sOnset', 'iOnset', 'sSwap', 'iSwap']] for dm in [dm] + dm.group('subject_nr'): print 'Subject %s' % i row = [i] # We use a 6 x 2 plot grid # XX X X X X # XX X X X X if i == 0: # Overall plot ax = plt.subplot2grid((2,6),(0,0), colspan=2, rowspan=2) linewidth = 1 title = 'Full data (N=%d)' % len(dm.select('cond != "swap"')) else: # Individual plots ax = plt.subplot2grid((2,6),((i-1)/4, 2+(i-1)%4)) linewidth = 1 title = '%d (N=%d)' % (i, len(dm.select('cond != "swap"'))) plt.text(0.9, 0.1, title, horizontalalignment='right', \ verticalalignment='bottom', transform=ax.transAxes) if i == 0: plt.xticks([0, 50, 100, 150, 200]) elif i > 0 and i < 5: plt.xticks([]) else: plt.xticks([0, 100]) if i > 0: plt.yticks([]) else: plt.yticks([0, -.01, -.02]) plt.ylim(-.025, .01) plt.axhline(0, color='black', linestyle=':') for cond in ('constant', 'onset', 'swap'): _dm = dm.select("cond == '%s'" % cond, verbose=False) dmWhite = _dm.select('saccCol == "white"', verbose=False) xAvg, yAvg, errAvg= TraceKit.getTraceAvg(_dm, signal='pupil', \ phase='postSacc', traceLen=postTraceLen, baseline=baseline, \ baselineLock=baselineLock) xWhite, yWhite, errWhite = TraceKit.getTraceAvg(dmWhite, \ signal='pupil', phase='postSacc', traceLen=postTraceLen, \ baseline=baseline, baselineLock=baselineLock) yWhite -= yAvg xWhite = xWhite[:prepWin] yWhite = yWhite[:prepWin] if cond == 'constant': col = constColor lineStyle = '-' elif cond == 'onset': col = onsetColor lineStyle = '--' else: col = swapColor lineStyle = '-.' yWhite *= -1 opts = Plot.regress(xWhite, yWhite, lineColor=col, symbolColor=col, label=cond, annotate=False, symbol=lineStyle, linestyle=':') s = 1000.*opts[0] _i = 1000.*opts[1] print 's = %.4f, i = %.4f' % (s, _i) if i > 0: row += [s, _i] else: plt.legend(frameon=False, loc='upper right') if i > 0: l.append(row) i += 1 saveFig('linFitPrepWin%s' % suffix, show=False) dm = DataMatrix(l) dm.save('output/%s/linFitPrepWin%s.csv' % (exp, suffix)) # Summarize the data and perform ttests on the model parameters for dv in ['s', 'i']: print'\nAnalyzing %s' % dv aConst = dm['%sConst' % dv] aOnset = dm['%sOnset' % dv] aSwap = dm['%sSwap' % dv] print 'Constant: M = %f, SE = %f' % (aConst.mean(), \ aConst.std() / np.sqrt(N)) print 'Onset: M = %f, SE = %f' % (aOnset.mean(), \ aOnset.std() / np.sqrt(N)) print 'Swap: M = %f, SE = %f' % (aSwap.mean(), \ aSwap.std() / np.sqrt(N)) # Standard t-tests t, p = ttest_rel(aConst, aOnset) print 'Const vs onset, t = %.4f, p = %.4f' % (t, p) t, p = ttest_rel(aSwap, aOnset) print 'Swap vs onset, t = %.4f, p = %.4f' % (t, p) t, p = ttest_rel(aConst, aSwap) print 'Const vs swap, t = %.4f, p = %.4f' % (t, p)
def fit(dm, suffix='', maxSmp=None): """ Fits the data based on an exponential pupil model. Arguments: dm -- DataMatrixpass Keyword arguments: suffix -- A suffix for the output files. (default='') maxSmp -- The maximum number of samples to base the fit on, or None for no limit. (default=None) """ fig = newFig(size=bigWide) plt.subplots_adjust(wspace=0, hspace=0) i = 0 l = [['subjectNr', 't0Const', 'speedConst', 'lim1Const', 'lim2Const', \ 't0Onset', 'speedOnset', 'lim1Onset', 'lim2Onset']] for dm in [dm] + dm.group('subject_nr'): print 'Subject %s' % i row = [i] # We use a 6 x 2 plot grid # XX X X X X # XX X X X X if i == 0: # Overall plot ax = plt.subplot2grid((2,6),(0,0), colspan=2, rowspan=2) # Draw 'window of preparation' plt.axvspan(0, prepWin, color=green[1], alpha=.2) linewidth = 1 title = 'Full data (N=%d)' % len(dm.select('cond != "swap"')) else: # Individual plots ax = plt.subplot2grid((2,6),((i-1)/4, 2+(i-1)%4)) linewidth = 1 title = '%d (N=%d)' % (i, len(dm.select('cond != "swap"'))) plt.text(0.9, 0.1, title, horizontalalignment='right', \ verticalalignment='bottom', transform=ax.transAxes) if i == 0: plt.xticks([0, 500, 1000, 1500]) elif i > 0 and i < 5: plt.xticks([]) else: plt.xticks([0, 1000]) if i > 0: plt.yticks([]) else: plt.yticks([0, -.1, -.2, -.3]) for cond in ('constant', 'onset'): _dm = dm.select("cond == '%s'" % cond, verbose=False) dmWhite = _dm.select('saccCol == "white"', verbose=False) xAvg, yAvg, errAvg= TraceKit.getTraceAvg(_dm, signal='pupil', \ phase='postSacc', traceLen=postTraceLen, baseline=baseline, \ baselineLock=baselineLock) xWhite, yWhite, errWhite = TraceKit.getTraceAvg(dmWhite, \ signal='pupil', phase='postSacc', traceLen=postTraceLen, \ baseline=baseline, baselineLock=baselineLock) yWhite -= yAvg if cond == 'constant': col = constColor lineStyle = '-' elif cond == 'onset': col = onsetColor lineStyle = '--' else: col = swapColor lineStyle = '-' if maxSmp != None: xWhite = xWhite[:maxSmp] yWhite = yWhite[:maxSmp] opts = fitCurve(xWhite, yWhite, col=col, label=cond, \ linewidth=linewidth, lineStyle=lineStyle) print 't0 = %.4f, s = %.4f, l1 = %.4f, l2 = %.4f' % tuple(opts) t0 = opts[0] if i > 0: row += list(opts) else: plt.legend(frameon=False, loc='upper right') print '%s : %f' % (cond, t0) if i > 0: l.append(row) i += 1 saveFig('fit%s' % suffix, show=False) dm = DataMatrix(l) dm.save('output/%s/fit%s.csv' % (exp, suffix)) # Summarize the data and perform ttests on the model parameters for dv in ['t0', 'speed', 'lim1', 'lim2']: print'\nAnalyzing %s' % dv aConst = dm['%sConst' % dv] aOnset = dm['%sOnset' % dv] print 'Constant: M = %f, SE = %f' % (aConst.mean(), \ aConst.std() / np.sqrt(N)) print 'Onset: M = %f, SE = %f' % (aOnset.mean(), \ aOnset.std() / np.sqrt(N)) t, p = ttest_rel(aConst, aOnset) print 'Const vs onset, t = %.4f, p = %.4f' % (t, p)
def getDM(exp, driftCorr = True, excludeErrors = True, saccTooFast = None, saccTooSlow = None,\ rtTooFast = None, rtTooSlow = None, rtVar = 'rtFromStim', \ exclFailedChecks = True, \ fixCheck1TooLong = 1000, fixCheck2TooLong = 1000, cutoffHeavy = 0, \ onlyControl = True, excludeFillers = True): """ Applies several exclusion criteria to obtain a filtered dm. Arguments: dm --- data matrix exp --- {"004A", "004B"}, string indicating whether first or second experiment is analysed Keyword arguments: excludeErrors --- Boolean indicating whether error trials should be excluded. Default = False. saccTooFast --- Cutoff for exclusion of too-fast saccades. Set to None to deactivate this filter. Default = 80. saccTooSlow --- Cutoff for exclusion of too-slow saccades. Set to None to deactivate this filter. rtTooFast --- Cutoff for exclusion of too-fast RTs. Set to None to deactivate this filter. rtTooSlow --- Cutoff for exclusion of too-slow RTs. Set to None to deactivate this filter. rtVar --- rt variable to use for excluding too fast and/or too slow response times. exclFailedChecks --- Boolean indicating whether or not to excude trials on which one or more fix checks failed. Default = False fixCheckTooLong1 --- Cutoff for excluding too long fixation checks. Set to None to deactivate this filter. Default = 700, based on looking at plt.hist(dm['durCheck1']) fixCheckTooLong2 --- Cutoff for excluding too long fixation check on object. Set to None to deactivate. Default = 450, based on looking at plt.hist(dm['durCheck2']) drifCorr --- cutoffHeavy --- minimum deviation necessary to indicate one side of the object as heavier. In px. Default = 8. onlyControl --- indicates whether only trials in which manipulation was not manipulated, should be included. Default = True. excludeFillers --- Default = True. """ if driftCorr: fName = "selected_dm_%s_WITH_drift_corr.csv" % exp else: fName = "selected_dm_%s_NO_drift_corr.csv" % exp if exp == "004C": data = "./dm_004C_simulation.csv" a = np.genfromtxt(data, dtype=None, delimiter=",") dm = DataMatrix(a) # Add some important column headers: dm = dm.addField("file", dtype = str) dm = dm.addField("accuracy") dm = dm.addField("contrast_side", dtype = str) dm["file"] = "simulation" dm["accuracy"] = 1 dm["contrast_side"] = "test" dm["contrast_side"][np.where(dm["mask_side"] == "right")] = "_left" dm["contrast_side"][np.where(dm["mask_side"] == "control")] = "control" dm["contrast_side"][np.where(dm["mask_side"] == "left")] = "right" else: dm = ascParser.parseAsc(exp = exp, driftCorr = driftCorr) # Start by applying some general selections (such that # the reported exclusion percentages will not differ depending # on when you execute those): # Exclude practice trials: dm = dm.select("rep != 'practice'") # For the second experiment, exclude Dash and Sebastiaan: if exp == "004B": # Exclude Sebastiaan: dm = dm.select('file != "00401.asc"') # Exclude Dash because he's left handed: dm = dm.select('file != "00402.asc"') if onlyControl: dm = dm.select("mask_side == 'control'") if excludeFillers: dm = dm.select("symm == 'asymm'") if excludeErrors: dm = dm.select('accuracy == 1') # 'Real' selections: # During parsing, tirals on which the variable 'response' did not contain # an int were given the value -1. Otherwise the dm will make all the # 'response' values strings. Therefore, start by excluding those eventual # -1's: dm = dm.select("response != -1") # Remove all trials on which saccLat1 doesn't have a value: dm = dm.select("saccLat1 != ''") # Negative initial saccade latencies should not happen: dm = dm.select('saccLat1 > 0.') # Add column header indicating whether drift correction was used: dm = dm.addField("driftCorr", dtype = str) dm["driftCorr"] = driftCorr # Add a column header indicating which experiment is analysed: dm = dm.addField("exp", dtype = str) dm["exp"] = exp # Add variable indicating whether CoG is to the left or to the # right: # For objects with handle right, and without mask applied: # - negative xCoG means: heavier on the left # - pos means: heavier on the right dm = dm.addField('heavySide', dtype = str) dm["heavySide"] = 'control' dm["heavySide"][np.where(dm["xCoG"] >= cutoffHeavy)] = 'right__' dm["heavySide"][np.where(dm["xCoG"] <= -cutoffHeavy)] = 'left__' # Some stuff we can't do for the simulation, because those columns don't # exist: if exp != "004C": # Add variable indicating experimental half (first or second): dm = dm.addField("half", dtype = str) dm["half"] = "first" dm["half"][np.where(dm["block_count"] >= 3)] = "second" if saccTooFast != None: dm = dm.select('saccLat1 > %s'%saccTooFast) if saccTooSlow != None: dm = dm.select('saccLat1 < %s'%saccTooSlow) if rtTooFast != None: dm = dm.select('%s > %s'%(rtVar,rtTooFast)) if rtTooSlow != None: dm = dm.select('%s < %s'%(rtVar,rtTooSlow)) # Filter on screen coordinates: # Y: if exp != "004C": dm = dm.select("endYRaw1 < %s" % constants.screenH) dm = dm.select("endYRaw1 > 0") # X: dm = dm.select("endXRaw1 < %s" % constants.screenW) dm = dm.select("endXRaw1 > 0") # Re-code initial y coordinates such that we can use one cutoff # for both upwards and downwards saccade to see whether they were in # the right direction (i.e. > center coordinate): dm = dm.addField("sacc_dir") dm["sacc_dir"] = dm["endYRaw1"] dm["sacc_dir"][dm.where("visual_field == 'upper'")] = \ dm["endYRaw1"][dm.where("visual_field == 'upper'")]+\ constants.yCen # Select saccades that were in the right vertical direction: dm.select("sacc_dir > %s" % str(constants.yCen)) # Exclude trials on which a fixation check failed or took too long: if exp == "004A": if exclFailedChecks: # Note why those will probably never lead to exclusions anymore: # in those cases durCheck1 or durCheck2 would have the value -1000 (because they # couldnt be calculated) and therefore are already excluded above. dm = dm.select('checkFixDotFailed == "False"') dm = dm.select('checkObjectFailed == "False"') if fixCheck1TooLong != None: dm = dm.select('durCheck1 < %s' % fixCheck1TooLong) if fixCheck2TooLong != None: dm = dm.select('durCheck2 < %s' % fixCheck2TooLong) if exp != "004C": # Negative new RT's should not happen: dm = dm.select('rtFromStim > 0') dm.save(fName) return dm
def corr(dm): """ Plots the between-subjects correlation between IOR and facilitation in object-centered and retinotopic conditions. Arguments: dm -- A DataMatrix. """ #dv = 'response_time' dv = 'iRt' dm = dm.select('correct == 1') l = [ ['ObjCue0', 'ObjCue1000', 'SpaCue0', 'SpaCue1000'] ] for _dm in dm.group('subject_nr'): _dm0 = _dm.select('postRotDelay == 0', verbose=False) _dm1000 = _dm.select('postRotDelay == 1000', verbose=False) Obj0Inv = _dm0.select('cond == "object-based"', verbose=False) \ .select('valid == "{1}invalid"', verbose=False)[dv] \ .mean() Obj0Val = _dm0.select('cond == "object-based"', verbose=False) \ .select('valid == "{0}valid"', verbose=False)[dv] \ .mean() Obj1000Inv = _dm1000.select('cond == "object-based"', verbose=False) \ .select('valid == "{1}invalid"', verbose=False)[dv] \ .mean() Obj1000Val = _dm1000.select('cond == "object-based"', verbose=False) \ .select('valid == "{0}valid"', verbose=False)[dv] \ .mean() Spa0Inv = _dm0.select('cond == "spatial"', verbose=False) \ .select('valid == "{1}invalid"', verbose=False)[dv] \ .mean() Spa0Val = _dm0.select('cond == "spatial"', verbose=False) \ .select('valid == "{0}valid"', verbose=False)[dv] \ .mean() Spa1000Inv = _dm1000.select('cond == "spatial"', verbose=False) \ .select('valid == "{1}invalid"', verbose=False)[dv] \ .mean() Spa1000Val = _dm1000.select('cond == "spatial"', verbose=False) \ .select('valid == "{0}valid"', verbose=False)[dv] \ .mean() if dv == 'iRt': Obj0Inv = 1./Obj0Inv Obj0Val = 1./Obj0Val Obj1000Inv = 1./Obj1000Inv Obj1000Val = 1./Obj1000Val Spa0Inv = 1./Spa0Inv Spa0Val = 1./Spa0Val Spa1000Inv = 1./Spa1000Inv Spa1000Val = 1./Spa1000Val ObjCue0 = Obj0Inv - Obj0Val ObjCue1000 = Obj1000Inv - Obj1000Val SpaCue0 = Spa0Inv - Spa0Val SpaCue1000 = Spa1000Inv - Spa1000Val l.append( [ObjCue0, ObjCue1000, SpaCue0, SpaCue1000] ) print '%s\t%s\t%s\t%s' % (ObjCue0, ObjCue1000, SpaCue0, SpaCue1000) _dm = DataMatrix(l) _dm.save('output/corr.%s.csv' % dv) fig = plt.figure(figsize=(8,8)) plt.subplots_adjust(wspace=.3, hspace=.3) plt.subplot(221) regressplot(_dm['ObjCue0'], _dm['SpaCue0']) plt.xlim(-200, 200) plt.ylim(-200, 200) plt.xlabel('Obj. cuing effect / short SOA (ms)') plt.ylabel('Ret. cuing effect / short SOA (ms)') plt.subplot(222) regressplot(_dm['ObjCue1000'], _dm['SpaCue1000']) plt.xlim(-200, 200) plt.ylim(-200, 200) plt.xlabel('Obj. cuing effect / long SOA (ms)') plt.ylabel('Ret. cuing effect / long SOA (ms)') plt.subplot(223) regressplot(_dm['ObjCue0'], _dm['ObjCue1000']) plt.xlim(-200, 200) plt.ylim(-200, 200) plt.xlabel('Obj. cuing effect / short SOA (ms)') plt.ylabel('Obj. cuing effect / long SOA (ms)') plt.subplot(224) regressplot(_dm['SpaCue0'], _dm['SpaCue1000']) plt.xlabel('Ret. cuing effect / short SOA (ms)') plt.ylabel('Ret. cuing effect / long SOA (ms)') plt.xlim(-200, 200) plt.ylim(-200, 200) plt.savefig('plot/corr.%s.png' % dv) plt.savefig('plot/corr.%s.svg' % dv) plt.show()
#!/usr/bin/env python from saliency import simulateScanpath from exparser.DataMatrix import DataMatrix import os from PIL import Image, ImageDraw for frame in os.listdir('frames'): print frame im = Image.open('frames/' + frame) dr = ImageDraw.Draw(im) l = simulateScanpath(im) i = 1 for p in l[1:]: t = p[0] x = p[1] y = p[2] dr.ellipse((x-5,y-5,x+5,y+5), outline='red') dr.text((x,y), '%d(%.0f)' % (i,t), fill='green') i += 1 im.save('simulation/png/%s' % frame) dm = DataMatrix(l) dm.save('simulation/csv/%s.csv' % frame[:-4])
def latencyCorr(dm): """ Determines the correlation between saccade latency and the latency of the PLR. Arguments: dm -- DataMatrix """ dm = dm.addField("saccLat2Bin", dtype=float) dm = dm.calcPerc("saccLat2", "saccLat2Bin", keys=["subject_nr"], nBin=10) # dm = dm.select('cond == "onset"') l = [["subject_nr", "cond", "bin", "saccLat", "t0"]] colors = TangoPalette.brightColors[:] * 10 for _dm in dm.group(["subject_nr", "saccLat2Bin"]): for cond in ("constant", "onset"): __dm = _dm.select("cond == '%s'" % cond, verbose=False) dmWhite = __dm.select('saccCol == "white"', verbose=False) xAvg, yAvg, errAvg = TraceKit.getTraceAvg( __dm, signal="pupil", phase="postSacc", traceLen=postTraceLen, baseline=baseline, baselineLock=baselineLock, ) xWhite, yWhite, errWhite = TraceKit.getTraceAvg( dmWhite, signal="pupil", phase="postSacc", traceLen=postTraceLen, baseline=baseline, baselineLock=baselineLock, ) yWhite -= yAvg opts = fitCurve(xWhite, yWhite, plot=False) t0 = opts[0] subject = __dm["subject_nr"][0] col = colors[int(subject)] saccLat = __dm["saccLat2"].mean() _bin = __dm["saccLat2Bin"][0] plt.plot(saccLat, t0, "o", color=col) l.append([subject, cond, _bin, saccLat, t0]) print subject, t0, saccLat dm = DataMatrix(l) dm.save("output/%s/latencyCorr.csv" % exp) print dm # plt.plot(dm['saccLat'], dm['t0'], '.') s, i, r, p, se = linregress(dm["saccLat"], dm["t0"]) print "r = %.4f, p = %.4f" % (r, p) plt.plot(dm["saccLat"], i + s * dm["saccLat"]) plt.show() newFig(size=(4.8, 2.4)) plt.subplots_adjust(bottom=0.2) pmX = PivotMatrix(dm, ["cond", "bin"], ["subject_nr"], "saccLat", colsWithin=True, err="se") print pmX pmY = PivotMatrix(dm, ["cond", "bin"], ["subject_nr"], "t0", colsWithin=True, err="se") print pmY xM = np.array(pmX.m[-2, 2:-2], dtype=float) xErr = np.array(pmX.m[-1, 2:-2], dtype=float) xMConst = xM[: len(xM) / 2] xMOnset = xM[len(xM) / 2 :] xErrConst = xErr[: len(xErr) / 2] xErrOnset = xErr[len(xErr) / 2 :] yM = np.array(pmY.m[-2, 2:-2], dtype=float) yErr = np.array(pmY.m[-1, 2:-2], dtype=float) yMConst = yM[: len(yM) / 2] yMOnset = yM[len(yM) / 2 :] yErrConst = yErr[: len(yErr) / 2] yErrOnset = yErr[len(yErr) / 2 :] plt.errorbar( xMConst, yMConst, xerr=xErrConst, yerr=yErrConst, label="Constant", capsize=0, color=constColor, fmt="o-" ) plt.errorbar(xMOnset, yMOnset, xerr=xErrOnset, yerr=yErrOnset, label="Onset", capsize=0, color=onsetColor, fmt="o-") plt.legend(frameon=False) plt.xlabel("Saccade latency (ms)") plt.ylabel("PLR latency (ms)") saveFig("latencyCorr") aov = AnovaMatrix(dm, ["cond", "bin"], "t0", "subject_nr") print aov aov.save("output/%s/aov.latencyCorr.csv" % exp)
def getDM(driftCorr, excludeErrors = False, saccTooFast = 80, saccTooSlow = None,\ rtTooFast = None, rtTooSlow = None, rtVar = 'rtFromStim'): """ Applies several exclusion criteria to obtain a filtered dm. Arguments: dm --- data matrix Keyword arguments: excludeErrors --- Boolean indicating whether error trials should be excluded. Default = False. saccTooFast --- Cutoff for exclusion of too-fast saccades. Set to None to deactivate this filter. Default = 80. saccTooSlow --- Cutoff for exclusion of too-slow saccades. Set to None to deactivate this filter. rtTooFast --- Cutoff for exclusion of too-fast RTs. Set to None to deactivate this filter. rtTooSlow --- Cutoff for exclusion of too-slow RTs. Set to None to deactivate this filter. rtVar --- rt variable to use for excluding too fast and/or too slow response times. drifCorr --- """ # Declare constants: #src = '/home/lotje/python-libs/studies/_004' if driftCorr: fName = "selected_dm_WITH_drift_corr.csv" else: fName = "selected_dm_NO_drift_corr.csv" if '--shortcut' in sys.argv: a = np.genfromtxt(fName, dtype=None, delimiter=",") dm = DataMatrix(a) #dm = CsvReader(fName, delimiter=',').dataMatrix() return dm dm = ascParser004B.parseAsc(driftCorr = driftCorr) # Exclude Sebastiaan: dm = dm.select('file != "00401.asc"') # Exclude Dash because he's left handed: dm = dm.select('file != "00402.asc"') # Add column header indicating whether drift correction was used: dm = dm.addField("driftCorr", dtype = str) dm["driftCorr"] = driftCorr # Make a new variable (instead of 'mask_side') that indicates the # highest contrast side: dm = dm.addField('contrast_side', dtype = str) dm['contrast_side'][np.where(dm['mask_side'] == "right")] = "_left" dm['contrast_side'][np.where(dm['mask_side'] == "left")] = "right" dm['contrast_side'][np.where(dm['mask_side'] == "control")] = "control" # Add variable indicating whether CoG is to the left or to the # right: # For objects with handle right, and without mask applied: # - negative xCoG means: heavier on the left # - pos means: heavier on the right dm = dm.addField('heavySide', dtype = str) dm["heavySide"] = 'left' dm["heavySide"][np.where(dm["xCoG"] >= 0)] = 'right' # Add variable indicating experimental half (first or second): dm = dm.addField("half", dtype = str) dm["half"] = "first" dm["half"][np.where(dm["block_count"] >= 3)] = "second" # Exclude practice trials: dm = dm.select("rep != 'practice'") # During parsing, tirals on which the variable 'response' did not contain # an int were given the value -1. Otherwise the dm will make all the # 'response' values strings. Therefore, start by excluding those eventual # -1's: dm = dm.select("response != -1") # Saccade latencies of 0 (or -1) should not happen: # If no saccade is detected during a trial, 'saccLat' is changed from -1000 # to -1 during parsing: dm = dm.select('saccLat1 > 0') # Negative new RT's should not happen: dm = dm.select('rtFromStim > 0') # Add values indicating whether the eyes landed towards the handle (positive # values) or towards the other side of the object (negative values): # Also, make sure all values are eventually converted to visual degrees: # If first landing position is empty, skip the trial: dm = dm.select("endX1 != ''") # Without any correction: dm = dm.addField("pxTowardsHandle") dm = dm.addField("degrTowardsHandle") indicesRight = np.where(dm["handle_side"] == 'right') indicesLeft = np.where(dm["handle_side"] == 'left') dm["pxTowardsHandle"][indicesRight] = (dm["endX1"][indicesRight]) dm["pxTowardsHandle"][indicesLeft] = dm["endX1"][indicesRight]*-1 dm["degrTowardsHandle"] = dm["pxTowardsHandle"]/studies._004.constants.ratioPxDegr ## With CoG correction based on the original bitmap (without mask): #dm = dm.addField("pxTowardsHandleCorr") #dm = dm.addField("degrTowardsHandleCorr") #indicesRight = np.where(dm["handle_side"] == 'right') #indicesLeft = np.where(dm["handle_side"] == 'left') #dm["pxTowardsHandleCorr"][indicesRight] = (dm["endXCorr"][indicesRight]) #dm["pxTowardsHandleCorr"][indicesLeft] = dm["endXCorr"][indicesRight]*-1 #dm["degrTowardsHandleCorr"] = dm["pxTowardsHandleCorr"]/constants.ratioPxDegr ## Wit CoG correction with taking mask into account:: #dm = dm.addField("pxTowardsHandleCorrMask") #dm = dm.addField("degrTowardsHandleCorrMask") #indicesRight = np.where(dm["handle_side"] == 'right') #indicesLeft = np.where(dm["handle_side"] == 'left') #dm["pxTowardsHandleCorrMask"][indicesRight] = \ #(dm["endXCorrMask"][indicesRight]) #dm["pxTowardsHandleCorrMask"][indicesLeft] = \ #dm["endXCorrMask"][indicesRight]*-1 #dm["degrTowardsHandleCorrMask"] = \ #dm["pxTowardsHandleCorrMask"]/constants.ratioPxDegr # Convert landing positions to visual degrees: dm = dm.addField("endXDegr") #dm = dm.addField("endXCorrDegr") #dm = dm.addField("endXCorrMaskDegr") dm["endXDegr"] = dm["endX1"]/studies._004.constants.ratioPxDegr #dm["endXCorrDegr"] = dm["endXCorr"]/constants.ratioPxDegr #dm["endXCorrMaskDegr"] = dm["endXCorrMask"]/constants.ratioPxDegr # Convert starting position to visual degrees: dm = dm.addField("startX1Degr") dm["startX1Degr"] = dm["startX1"]/studies._004.constants.ratioPxDegr #dm = dm.addField("rtFromLanding") #dm['rtFromLanding'] = dm['rtFromStim']-dm['saccLandingTime1'] if saccTooFast != None: dm = dm.select('saccLat1 > %s'%saccTooFast) if saccTooSlow != None: dm = dm.select('saccLat1 < %s'%saccTooSlow) if rtTooFast != None: dm = dm.select('%s > %s'%(rtVar,rtTooFast)) if rtTooSlow != None: dm = dm.select('%s < %s'%(rtVar,rtTooSlow)) if excludeErrors: dm = dm.select('accuracy == 1') dm.save(fName) return dm