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
