CNC/ET_PDToolkit
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

init

Browse Source
This commit is contained in:
Jan-Bernard Marsman
2018-06-12 14:49:55 +02:00
parent 1edacb997d
commit d2cf032fab
230 changed files with 3192360 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
PDToolkit/@PDSession/.DS_Store vendored Normal file
View File

Binary file not shown.

49
PDToolkit/@PDSession/PDSession.m Normal file
View File

@@ -0,0 +1,49 @@
classdef PDSession
properties
datafile
eye
settings
trials = PDTrial;
date
time
name
labels
samples
sampling_rate
events_
trial_start_pattern
trial_end_pattern
baseline_type
baseline_onset_pattern
baseline_offset_pattern
stimulus_onset_pattern
stimulus_offset_pattern
label_patterns
label_dependencies
end
methods
function[obj] = PDSession(varargin)
if nargin==0
error('Session requires a PDSubject')
else
obj.datafile = varargin{1};
obj.eye = 'left' %% default to left eye recording
[basedir obj.name ext] = fileparts(obj.datafile);
obj.importData(varargin{1});
obj = obj.setFramerate;
end
end
function readEDF(filename)
end
end
end

27
PDToolkit/@PDSession/check_patterns.m Normal file
View File

@@ -0,0 +1,27 @@
function[obj] = check_patterns(obj)
if isempty(obj.trial_start_pattern)
error('No text pattern for `trial start` was provided');
end
% if isempty(obj.trial_end_pattern)
% warning('No text pattern for `trial end` was provided : using start trial');
% obj = obj.setPattern('trial_end', obj.trial_start_pattern);
% end
if isempty(obj.stimulus_onset_pattern)
warning('No stimulus onset pattern was provided : using start trial');
obj.stimulus_onset_pattern = obj.trial_start_pattern;
end
if isempty(obj.stimulus_offset_pattern)
obj.stimulus_offset_pattern = obj.trial_end_pattern;
end
if isempty(obj.baseline_onset_pattern)
obj.baseline_offset_pattern = obj.trial_start_pattern;
end
if isempty(obj.baseline_offset_pattern)
obj.baseline_offset_pattern = obj.stimulus_onset_pattern;
end

18
PDToolkit/@PDSession/deconvolve.m Normal file
View File

@@ -0,0 +1,18 @@
function[obj] = deconvolve(obj, settings)
%% Perform pupil deconvolution for the entire session
if nargin ==1
selected_trials = 1:length(obj.trials)
else
selected_trials = settings.selection;
end
h = waitbar(0, 'Performing pupil deconvolution...');
for t = 1:length(selected_trials)
selected_trial = selected_trials(t)
obj.trials(selected_trial) = obj.trials(selected_trial).deconvolve(settings);
waitbar(t/length(selected_trials), h);
end

20
PDToolkit/@PDSession/display_and_log.m Normal file
View File

@@ -0,0 +1,20 @@
function[obj] = display_and_log(obj, varargin)
if nargin ==2
text = varargin{1};
truncate = varargin{2};
else
text = varargin{1};
truncate=0;
end
code = 'a+';
if truncate
code = 'w+';
end
display(sprintf(text));
fp = fopen('information.txt',code);
text = [text '\n'];
fprintf(fp, text);
fclose(fp);

136
PDToolkit/@PDSession/getTimeLockedTrialMatrix.m Normal file
View File

@@ -0,0 +1,136 @@
function[pre_mat post_mat rel_time trial_ind] = getTimeLockedTrialMatrix(objs, varargin)
%% getTimeLockedTrialMatrix returns each trial trace shifted for a marker
% or event timestamp
%
% Usage
% [mat trial_ind] = PDSession.getTimeLockedTrialMatrix(event_code [,selection, eye, signal_type, corrected])
%
% - mat
% Matrix of n x l, n = number of trials, l = maximum length of all traces
% - trial_ind
% Vector containing the selected trials after quality
% thresholding
% - event_code
% Event code (or Label string that is matched.)
% - selection
% Vector of selected / requested trials%
% - eye
% 'left', 'right', or 'both' (default = 'left')
% - signal_type
% 'raw', 'interpolated', 'filtered' (default = 'filtered');
% - corrected
% 0 /1, use baseline corrected signals (default : 1)
%
% Examples:
%
% *) with one parameter : session.getTrialMatrix('stimulus start');
% *) with two parameters : session.getTrialMatrix('all', 'left');
% *) with three parameters : session.getTrialMatrix('all', 'left', 'interpolated');
% *) with four parameters : session.getTrialMatrix(1:10, 'right', 'interpolated', 1);
%
% Usage :
% function[mat trial_ind] = getTimeLockedTrialMatrix(obj, varargin)
%% determine input (this can be optimized...)
if nargin == 1
error('No event code provided')
end
if nargin == 2
event_code = varargin{1};
selection = [];
eye = 'left';
signal_type = 'filtered';
corrected = 1;
end
if nargin == 3
event_code = varargin{1};
selection = varargin{2};
eye = 'left';
signal_type = 'filtered';
corrected = 1;
end
if nargin == 4
event_code = varargin{1};
selection = varargin{2};
eye = varargin{3};
signal_type = 'filtered';
corrected = 1;
end
if nargin == 5
event_code = varargin{1};
selection = varargin{2};
eye = varargin{3};
signal_type = varargin{4};
corrected = 1;
end
if nargin == 6
event_code = varargin{1};
selection = varargin{2};
eye = varargin{3};
signal_type = varargin{4};
corrected = varargin{5};
end
if corrected == 1
data_field = 'baseline_corrected';
else
data_field = 'raw';
end
%%
for s = 1:length(objs)
obj = objs(s);
if isempty(selection)
selection = 1:length(obj.trials);
end
%% incorporate trial quality
q_objs = [obj.trials(selection).quality];
q_vals = cat(1, q_objs.(eye));
valid_trials = q_vals >= obj.settings.QualityThreshold;
trial_ind = find(valid_trials);
trials = [obj.trials(valid_trials).data];
t_objs = [trials.(eye)]; data_objs = [t_objs.(data_field)];
max_trial_length = 0;
indices = obj.trials.getIndexForEvent(event_code);
indices = indices(trial_ind);
%% determine the maximum length of pre and post trial
for i = 1:length(data_objs)
if max_trial_length < length(data_objs(i).(signal_type)(1:indices(i)));
max_trial_length_pre = length(data_objs(i).(signal_type)(1:indices(i)-1));
max_trial_length_post = length(data_objs(i).(signal_type)(indices(i):end));
end
end
%% predefine matrices (selected trials x max length)
pre_mat = nan(length(trial_ind), max_trial_length_pre);
post_mat = nan(length(trial_ind), max_trial_length_post);
%% cut the trials in pre and post marker
for t = 1:length(trials)
pre_trace = trials(t).(eye).(data_field).(signal_type)(1:indices(i)-1);
pre_mat(t,end-length(pre_trace)+1:end) = pre_trace;
post_trace = trials(t).(eye).(data_field).(signal_type)(indices(i):end);
post_mat(t,1:length(post_trace)) = post_trace;
end
rel_time = repmat(-length(pre_mat):length(post_mat)-1,length(trials),1);
end

90
PDToolkit/@PDSession/getTrialMatrix.m Normal file
View File

@@ -0,0 +1,90 @@
function[mat trial_ind] = getTrialMatrix(obj, varargin)
%% getTrialMatrix returns traces of all selected trials in selection, surviving the Quality Threshold
%
% Usage
% [mat trial_ind] = PDSession.getTrialMatrix([selection, eye, signal_type, corrected])
%
% - mat
% Matrix of n x l, n = number of trials, l = maximum length of all traces
% - trial_ind
% Vector containing the selected trials after quality
% thresholding
% - selection
% Vector of selected / requested trials
% - eye
% 'left', 'right', or 'both' (default = 'left')
% - signal_type
% 'raw', 'interpolated', 'filtered' (default = 'filtered');
% - corrected
% 0 /1, use baseline corrected signals (default : 1)
%
% Examples:
%
% *) without parameters : session.getTrialMatrix;
% *) with one parameter : session.getTrialMatrix(1:10);
% *) with two parameters : session.getTrialMatrix('all', 'left');
% *) with three parameters : session.getTrialMatrix('all', 'left', 'interpolated');
% *) with four parameters : session.getTrialMatrix(1:10, 'right', 'interpolated', 1);
if nargin == 2
selection = varargin{1};
eye = 'left';
signal_type = 'filtered';
corrected = 1;
end
if nargin == 3
selection = varargin{1};
eye = varargin{2};
signal_type = 'filtered';
corrected = 1;
end
if nargin == 4
selection = varargin{1};
eye = varargin{2};
signal_type = varargin{3};
corrected = 1;
end
if corrected == 1
data_field = 'baseline_corrected';
else
data_field = 'raw';
end
if ~ismember(eye,{'left', 'right', 'both'});
eye = 'left';
end
if isempty(selection)
selection = 1:length(obj.trials);
end
%% Quality check
q_objs = [obj.trials(selection).quality];
q_vals = cat(1, q_objs.(eye));
valid_trials = q_vals >= obj.settings.QualityThreshold;
trial_ind = find(valid_trials);
trials = [obj.trials(valid_trials).data];
t_objs = [trials.(eye)]; data_objs = [t_objs.(data_field)];
max_trial_length = 0;
for i = 1:length(data_objs)
if max_trial_length < length(data_objs(i).(signal_type));
max_trial_length = length(data_objs(i).(signal_type));
end
end
%% define empty output matrix with zeros
mat = nan(length(valid_trials), max_trial_length);
for t = 1:length(trials)
trace = trials(t).(eye).(data_field).(signal_type);
mat(t,1:length(trace)) = trace;
end

24
PDToolkit/@PDSession/importData.m Normal file
View File

@@ -0,0 +1,24 @@
function[obj] = importData(obj, varargin)
if (nargin == 1)
if (isempty(obj.filename))
error(' Filename has not been set')
end
else
obj.datafile = varargin{1};
end
[base filename ext] = fileparts(obj.datafile);
if strcmp(lower(ext), '.edf');
obj.readEDF;
end
if strcmp(lower(ext), '.asc');
obj.read_ASC;
end
if strcmp(lower(ext), '.gazedata');
obj.read_gazedata;
end
end

450
PDToolkit/@PDSession/information.txt Normal file
View File

@@ -0,0 +1,450 @@
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 4 blinks filtered ( 5 missing data events); quality : 96 percent
*) 6 blinks filtered ( 6 missing data events); quality : 96 percent
*) 4 blinks filtered ( 6 missing data events); quality : 96 percent
*) 5 blinks filtered ( 6 missing data events); quality : 95 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 2 blinks filtered ( 4 missing data events); quality : 97 percent
*) 3 blinks filtered ( 3 missing data events); quality : 97 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 7 blinks filtered ( 8 missing data events); quality : 95 percent
*) 4 blinks filtered ( 5 missing data events); quality : 95 percent
*) 4 blinks filtered ( 6 missing data events); quality : 94 percent
*) 1 blinks filtered ( 2 missing data events); quality : 97 percent
*) 6 blinks filtered ( 7 missing data events); quality : 93 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 4 blinks filtered ( 6 missing data events); quality : 95 percent
*) 5 blinks filtered ( 7 missing data events); quality : 95 percent
*) 2 blinks filtered ( 4 missing data events); quality : 97 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 4 blinks filtered ( 6 missing data events); quality : 95 percent
*) 4 blinks filtered ( 6 missing data events); quality : 95 percent
*) 5 blinks filtered ( 6 missing data events); quality : 95 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 4 missing data events); quality : 96 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 0 blinks filtered ( 2 missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 3 blinks filtered ( 5 missing data events); quality : 95 percent
*) 9 blinks filtered (10 missing data events); quality : 90 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 4 blinks filtered ( 6 missing data events); quality : 95 percent
*) 4 blinks filtered ( 4 missing data events); quality : 97 percent
*) 3 blinks filtered ( 4 missing data events); quality : 97 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 0 blinks filtered ( 3 missing data events); quality : 97 percent
*) 3 blinks filtered ( 6 missing data events); quality : 95 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 4 blinks filtered ( 5 missing data events); quality : 95 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 97 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 4 blinks filtered ( 5 missing data events); quality : 95 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 2 blinks filtered ( 5 missing data events); quality : 95 percent
*) 3 blinks filtered ( 5 missing data events); quality : 96 percent
*) 1 blinks filtered ( 3 missing data events); quality : 98 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 2 blinks filtered ( 4 missing data events); quality : 95 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 3 missing data events); quality : 97 percent
*) 3 blinks filtered ( 3 missing data events); quality : 96 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 3 blinks filtered ( 5 missing data events); quality : 94 percent
*) 5 blinks filtered ( 7 missing data events); quality : 94 percent
*) 3 blinks filtered ( 3 missing data events); quality : 96 percent
*) 3 blinks filtered ( 4 missing data events); quality : 96 percent
*) 3 blinks filtered ( 4 missing data events); quality : 96 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 3 blinks filtered ( 3 missing data events); quality : 96 percent
*) 7 blinks filtered ( 9 missing data events); quality : 91 percent
*) 8 blinks filtered ( 9 missing data events); quality : 91 percent
*) 1 blinks filtered ( 2 missing data events); quality : 97 percent
*) 3 blinks filtered ( 5 missing data events); quality : 95 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 8 blinks filtered ( 9 missing data events); quality : 93 percent
*) 5 blinks filtered ( 7 missing data events); quality : 94 percent
*) 1 blinks filtered ( 2 missing data events); quality : 97 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 4 blinks filtered ( 4 missing data events); quality : 97 percent
*) 4 blinks filtered ( 5 missing data events); quality : 96 percent
*) 2 blinks filtered ( 4 missing data events); quality : 95 percent
*) 7 blinks filtered ( 8 missing data events); quality : 93 percent
*) 1 blinks filtered ( 2 missing data events); quality : 96 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 97 percent
*) 3 blinks filtered ( 6 missing data events); quality : 94 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 7 blinks filtered ( 8 missing data events); quality : 94 percent
*) 4 blinks filtered ( 5 missing data events); quality : 96 percent
*) 10 blinks filtered (12 missing data events); quality : 89 percent
*) 2 blinks filtered ( 5 missing data events); quality : 93 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 3 blinks filtered ( 4 missing data events); quality : 95 percent
*) 3 blinks filtered ( 5 missing data events); quality : 93 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 5 blinks filtered ( 8 missing data events); quality : 93 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 13 blinks filtered (14 missing data events); quality : 88 percent
*) 6 blinks filtered ( 7 missing data events); quality : 94 percent
*) 7 blinks filtered ( 9 missing data events); quality : 86 percent
*) 4 blinks filtered ( 6 missing data events); quality : 94 percent
*) 5 blinks filtered ( 7 missing data events); quality : 88 percent
*) 3 blinks filtered ( 6 missing data events); quality : 94 percent
*) 4 blinks filtered ( 6 missing data events); quality : 93 percent
*) 6 blinks filtered ( 8 missing data events); quality : 92 percent
*) 3 blinks filtered ( 6 missing data events); quality : 90 percent
*) 5 blinks filtered ( 7 missing data events); quality : 91 percent
*) 3 blinks filtered ( 5 missing data events); quality : 94 percent
*) 7 blinks filtered ( 8 missing data events); quality : 90 percent
*) 6 blinks filtered ( 8 missing data events); quality : 90 percent
*) 6 blinks filtered ( 7 missing data events); quality : 91 percent
*) 6 blinks filtered ( 7 missing data events); quality : 83 percent
*) 6 blinks filtered ( 8 missing data events); quality : 83 percent
*) 17 blinks filtered (18 missing data events); quality : 83 percent
*) 5 blinks filtered ( 6 missing data events); quality : 93 percent
*) 9 blinks filtered (11 missing data events); quality : 83 percent
*) 11 blinks filtered (13 missing data events); quality : 83 percent
*) 21 blinks filtered (21 missing data events); quality : 80 percent
*) 9 blinks filtered (11 missing data events); quality : 90 percent
*) 10 blinks filtered (12 missing data events); quality : 85 percent
*) 6 blinks filtered ( 8 missing data events); quality : 91 percent
*) 2 blinks filtered ( 5 missing data events); quality : 94 percent
*) 13 blinks filtered (15 missing data events); quality : 86 percent
*) 2 blinks filtered ( 5 missing data events); quality : 95 percent
*) 3 blinks filtered ( 5 missing data events); quality : 94 percent
*) 7 blinks filtered ( 8 missing data events); quality : 93 percent
*) 3 blinks filtered ( 6 missing data events); quality : 94 percent
*) 8 blinks filtered (10 missing data events); quality : 92 percent
*) 11 blinks filtered (11 missing data events); quality : 84 percent
*) 2 blinks filtered ( 4 missing data events); quality : 96 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 7 blinks filtered ( 9 missing data events); quality : 92 percent
*) 11 blinks filtered (12 missing data events); quality : 86 percent
*) 4 blinks filtered ( 7 missing data events); quality : 94 percent
*) 9 blinks filtered (10 missing data events); quality : 91 percent
*) 8 blinks filtered (10 missing data events); quality : 90 percent
*) 2 blinks filtered ( 5 missing data events); quality : 95 percent
*) 5 blinks filtered ( 8 missing data events); quality : 93 percent
*) 15 blinks filtered (17 missing data events); quality : 86 percent
*) 11 blinks filtered (12 missing data events); quality : 88 percent
*) 8 blinks filtered (10 missing data events); quality : 91 percent
*) 5 blinks filtered ( 7 missing data events); quality : 93 percent
*) 8 blinks filtered (10 missing data events); quality : 90 percent
*) 5 blinks filtered ( 7 missing data events); quality : 94 percent
*) 7 blinks filtered ( 8 missing data events); quality : 93 percent
*) 1 blinks filtered ( 5 missing data events); quality : 95 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 5 blinks filtered ( 7 missing data events); quality : 94 percent
*) 4 blinks filtered ( 7 missing data events); quality : 89 percent
*) 3 blinks filtered ( 6 missing data events); quality : 94 percent
*) 5 blinks filtered ( 6 missing data events); quality : 93 percent
*) 6 blinks filtered ( 8 missing data events); quality : 90 percent
*) 6 blinks filtered ( 7 missing data events); quality : 93 percent
*) 5 blinks filtered ( 7 missing data events); quality : 93 percent
*) 0 blinks filtered ( 2 missing data events); quality : 97 percent
*) 2 blinks filtered ( 5 missing data events); quality : 95 percent
*) 4 blinks filtered ( 6 missing data events); quality : 91 percent
*) 4 blinks filtered ( 6 missing data events); quality : 94 percent
*) 4 blinks filtered ( 7 missing data events); quality : 94 percent
*) 3 blinks filtered ( 5 missing data events); quality : 94 percent
*) 5 blinks filtered ( 7 missing data events); quality : 92 percent
*) 4 blinks filtered ( 7 missing data events); quality : 93 percent
*) 2 blinks filtered ( 3 missing data events); quality : 96 percent
*) 5 blinks filtered ( 6 missing data events); quality : 93 percent
*) 6 blinks filtered ( 7 missing data events); quality : 91 percent
*) 3 blinks filtered ( 5 missing data events); quality : 93 percent
*) 4 blinks filtered ( 6 missing data events); quality : 95 percent
*) 9 blinks filtered (10 missing data events); quality : 91 percent
*) 11 blinks filtered (13 missing data events); quality : 86 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 4 blinks filtered ( 7 missing data events); quality : 93 percent
*) 8 blinks filtered ( 9 missing data events); quality : 75 percent
*) 8 blinks filtered ( 9 missing data events); quality : 82 percent
*) 11 blinks filtered (12 missing data events); quality : 89 percent
*) 4 blinks filtered ( 6 missing data events); quality : 88 percent
*) 5 blinks filtered ( 7 missing data events); quality : 86 percent
*) 7 blinks filtered ( 8 missing data events); quality : 90 percent
*) 8 blinks filtered (10 missing data events); quality : 89 percent
*) 4 blinks filtered ( 6 missing data events); quality : 94 percent
*) 9 blinks filtered (10 missing data events); quality : 88 percent
*) 7 blinks filtered ( 9 missing data events); quality : 88 percent
*) 11 blinks filtered (13 missing data events); quality : 88 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 7 blinks filtered ( 7 missing data events); quality : 95 percent
*) 10 blinks filtered (10 missing data events); quality : 92 percent
*) 3 blinks filtered ( 6 missing data events); quality : 95 percent
*) 10 blinks filtered (12 missing data events); quality : 86 percent
*) 14 blinks filtered (14 missing data events); quality : 90 percent
*) 9 blinks filtered (11 missing data events); quality : 92 percent
*) 12 blinks filtered (13 missing data events); quality : 87 percent
*) 11 blinks filtered (12 missing data events); quality : 90 percent
*) 9 blinks filtered (11 missing data events); quality : 91 percent
*) 10 blinks filtered (13 missing data events); quality : 90 percent
*) 24 blinks filtered (24 missing data events); quality : 80 percent
*) 25 blinks filtered (25 missing data events); quality : 83 percent
*) 14 blinks filtered (15 missing data events); quality : 86 percent
*) 11 blinks filtered (12 missing data events); quality : 86 percent
*) 12 blinks filtered (13 missing data events); quality : 89 percent
*) 27 blinks filtered (27 missing data events); quality : 80 percent
*) 16 blinks filtered (16 missing data events); quality : 82 percent
*) 15 blinks filtered (15 missing data events); quality : 86 percent
*) 20 blinks filtered (21 missing data events); quality : 83 percent
*) 11 blinks filtered (12 missing data events); quality : 91 percent
*) 14 blinks filtered (14 missing data events); quality : 88 percent
*) 11 blinks filtered (13 missing data events); quality : 78 percent
*) 22 blinks filtered (22 missing data events); quality : 79 percent
*) 17 blinks filtered (17 missing data events); quality : 86 percent
*) 27 blinks filtered (27 missing data events); quality : 75 percent
*) 11 blinks filtered (12 missing data events); quality : 88 percent
*) 48 blinks filtered (48 missing data events); quality : 73 percent
*) 22 blinks filtered (22 missing data events); quality : 84 percent
*) 36 blinks filtered (36 missing data events); quality : 76 percent
*) 11 blinks filtered (13 missing data events); quality : 86 percent
*) 17 blinks filtered (17 missing data events); quality : 83 percent
*) 10 blinks filtered (11 missing data events); quality : 87 percent
*) 18 blinks filtered (18 missing data events); quality : 82 percent
*) 20 blinks filtered (21 missing data events); quality : 87 percent
*) 11 blinks filtered (11 missing data events); quality : 87 percent
*) 49 blinks filtered (49 missing data events); quality : 71 percent
*) 18 blinks filtered (19 missing data events); quality : 81 percent
*) 23 blinks filtered (23 missing data events); quality : 82 percent
*) 35 blinks filtered (35 missing data events); quality : 77 percent
*) 14 blinks filtered (14 missing data events); quality : 88 percent
*) 16 blinks filtered (16 missing data events); quality : 85 percent
*) 16 blinks filtered (16 missing data events); quality : 84 percent
*) 20 blinks filtered (21 missing data events); quality : 73 percent
*) 21 blinks filtered (21 missing data events); quality : 83 percent
*) 3 blinks filtered ( 4 missing data events); quality : 96 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 3 blinks filtered ( 4 missing data events); quality : 95 percent
*) 16 blinks filtered (17 missing data events); quality : 82 percent
*) 9 blinks filtered (10 missing data events); quality : 89 percent
*) 11 blinks filtered (11 missing data events); quality : 88 percent
*) 9 blinks filtered (10 missing data events); quality : 92 percent
*) 10 blinks filtered (11 missing data events); quality : 90 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 10 blinks filtered (10 missing data events); quality : 91 percent
*) 9 blinks filtered ( 9 missing data events); quality : 92 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 9 blinks filtered ( 9 missing data events); quality : 90 percent
*) 19 blinks filtered (19 missing data events); quality : 84 percent
*) 6 blinks filtered ( 6 missing data events); quality : 94 percent
*) 13 blinks filtered (14 missing data events); quality : 87 percent
*) 2 blinks filtered ( 5 missing data events); quality : 94 percent
*) 17 blinks filtered (18 missing data events); quality : 82 percent
*) 5 blinks filtered ( 5 missing data events); quality : 88 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 12 blinks filtered (13 missing data events); quality : 87 percent
*) 16 blinks filtered (16 missing data events); quality : 85 percent
*) 12 blinks filtered (13 missing data events); quality : 88 percent
*) 13 blinks filtered (13 missing data events); quality : 88 percent
*) 14 blinks filtered (15 missing data events); quality : 89 percent
*) 17 blinks filtered (17 missing data events); quality : 86 percent
*) 11 blinks filtered (13 missing data events); quality : 88 percent
*) 14 blinks filtered (14 missing data events); quality : 89 percent
*) 5 blinks filtered ( 6 missing data events); quality : 92 percent
*) 27 blinks filtered (27 missing data events); quality : 82 percent
*) 3 blinks filtered ( 5 missing data events); quality : 95 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 8 blinks filtered (10 missing data events); quality : 93 percent
*) 28 blinks filtered (29 missing data events); quality : 82 percent
*) 14 blinks filtered (15 missing data events); quality : 88 percent
*) 9 blinks filtered (10 missing data events); quality : 90 percent
*) 57 blinks filtered (57 missing data events); quality : 68 percent
*) 63 blinks filtered (63 missing data events); quality : 66 percent
*) 36 blinks filtered (36 missing data events); quality : 77 percent
*) 12 blinks filtered (13 missing data events); quality : 87 percent
*) 30 blinks filtered (30 missing data events); quality : 77 percent
*) 74 blinks filtered (74 missing data events); quality : 63 percent
*) 1 blinks filtered ( 2 missing data events); quality : 96 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 95 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 3 missing data events); quality : 97 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 3 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 100 percent
*) 0 blinks filtered ( 3 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 100 percent
*) 1 blinks filtered ( 3 missing data events); quality : 98 percent
*) 1 blinks filtered ( 3 missing data events); quality : 96 percent
*) 2 blinks filtered ( 3 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) 4 blinks filtered ( 5 missing data events); quality : 96 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 3 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 100 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 5 blinks filtered ( 5 missing data events); quality : 96 percent
*) 7 blinks filtered ( 8 missing data events); quality : 91 percent
*) 2 blinks filtered ( 3 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 3 blinks filtered ( 4 missing data events); quality : 97 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 2 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 4 blinks filtered ( 6 missing data events); quality : 96 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 3 blinks filtered ( 5 missing data events); quality : 97 percent
*) 1 blinks filtered ( 3 missing data events); quality : 97 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 100 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 2 blinks filtered ( 3 missing data events); quality : 97 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 98 percent
*) 4 blinks filtered ( 4 missing data events); quality : 96 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 1 blinks filtered ( 1 missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) blinks filtered ( missing data events); quality : 99 percent
*) 0 blinks filtered ( 1 missing data events); quality : 99 percent
*) 1 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 0 blinks filtered ( 2 missing data events); quality : 98 percent
*) 6 blinks filtered ( 8 missing data events); quality : 93 percent
*) 11 blinks filtered (12 missing data events); quality : 90 percent
*) 9 blinks filtered (10 missing data events); quality : 90 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 12 blinks filtered (12 missing data events); quality : 89 percent
*) 4 blinks filtered ( 6 missing data events); quality : 93 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 6 blinks filtered ( 7 missing data events); quality : 92 percent
*) 5 blinks filtered ( 7 missing data events); quality : 93 percent
*) 7 blinks filtered ( 9 missing data events); quality : 92 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 11 blinks filtered (11 missing data events); quality : 82 percent
*) 16 blinks filtered (16 missing data events); quality : 85 percent
*) 7 blinks filtered ( 8 missing data events); quality : 90 percent
*) 9 blinks filtered (10 missing data events); quality : 89 percent
*) 8 blinks filtered (10 missing data events); quality : 89 percent
*) 9 blinks filtered (10 missing data events); quality : 92 percent
*) 9 blinks filtered ( 9 missing data events); quality : 92 percent
*) 11 blinks filtered (11 missing data events); quality : 90 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 11 blinks filtered (11 missing data events); quality : 88 percent
*) 8 blinks filtered ( 9 missing data events); quality : 92 percent
*) 10 blinks filtered (11 missing data events); quality : 88 percent
*) 14 blinks filtered (14 missing data events); quality : 82 percent
*) 12 blinks filtered (12 missing data events); quality : 85 percent
*) 11 blinks filtered (11 missing data events); quality : 86 percent
*) 13 blinks filtered (13 missing data events); quality : 86 percent
*) 14 blinks filtered (14 missing data events); quality : 82 percent
*) 15 blinks filtered (15 missing data events); quality : 81 percent
*) 8 blinks filtered ( 9 missing data events); quality : 77 percent
*) 13 blinks filtered (13 missing data events); quality : 85 percent
*) 13 blinks filtered (13 missing data events); quality : 83 percent
*) 10 blinks filtered (10 missing data events); quality : 84 percent
*) 9 blinks filtered (10 missing data events); quality : 87 percent
*) 11 blinks filtered (12 missing data events); quality : 87 percent
*) 5 blinks filtered ( 6 missing data events); quality : 90 percent
*) 18 blinks filtered (18 missing data events); quality : 78 percent
*) 6 blinks filtered ( 8 missing data events); quality : 88 percent
*) 10 blinks filtered (11 missing data events); quality : 88 percent
*) 11 blinks filtered (12 missing data events); quality : 88 percent
*) 8 blinks filtered ( 9 missing data events); quality : 90 percent
*) 9 blinks filtered ( 9 missing data events); quality : 87 percent
*) 12 blinks filtered (12 missing data events); quality : 78 percent
*) 9 blinks filtered ( 9 missing data events); quality : 86 percent
*) 12 blinks filtered (12 missing data events); quality : 87 percent
*) 12 blinks filtered (12 missing data events); quality : 85 percent
*) 8 blinks filtered (10 missing data events); quality : 89 percent
*) 5 blinks filtered ( 6 missing data events); quality : 93 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 11 blinks filtered (11 missing data events); quality : 89 percent
*) 14 blinks filtered (14 missing data events); quality : 83 percent
*) 9 blinks filtered (10 missing data events); quality : 78 percent
*) 10 blinks filtered (11 missing data events); quality : 87 percent
*) 7 blinks filtered ( 8 missing data events); quality : 90 percent
*) 20 blinks filtered (20 missing data events); quality : 79 percent
*) 10 blinks filtered (10 missing data events); quality : 89 percent
*) 6 blinks filtered ( 8 missing data events); quality : 92 percent
*) 7 blinks filtered ( 9 missing data events); quality : 91 percent
*) 5 blinks filtered ( 7 missing data events); quality : 93 percent
*) 7 blinks filtered ( 9 missing data events); quality : 89 percent
*) 4 blinks filtered ( 5 missing data events); quality : 94 percent
*) 5 blinks filtered ( 6 missing data events); quality : 93 percent
*) 4 blinks filtered ( 5 missing data events); quality : 94 percent
*) 6 blinks filtered ( 8 missing data events); quality : 92 percent
*) 11 blinks filtered (11 missing data events); quality : 86 percent
*) 6 blinks filtered ( 8 missing data events); quality : 88 percent
*) 3 blinks filtered ( 6 missing data events); quality : 92 percent
*) 9 blinks filtered (10 missing data events); quality : 87 percent
*) 5 blinks filtered ( 7 missing data events); quality : 92 percent
*) 11 blinks filtered (12 missing data events); quality : 88 percent
*) 9 blinks filtered (10 missing data events); quality : 89 percent
*) 5 blinks filtered ( 6 missing data events); quality : 94 percent
*) 7 blinks filtered ( 9 missing data events); quality : 90 percent
*) 5 blinks filtered ( 7 missing data events); quality : 93 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 9 blinks filtered (10 missing data events); quality : 88 percent
*) 5 blinks filtered ( 7 missing data events); quality : 94 percent
*) 6 blinks filtered ( 7 missing data events); quality : 93 percent
*) 7 blinks filtered ( 8 missing data events); quality : 92 percent
*) 8 blinks filtered (10 missing data events); quality : 90 percent
*) 8 blinks filtered (10 missing data events); quality : 90 percent
*) 6 blinks filtered ( 6 missing data events); quality : 90 percent
*) 10 blinks filtered (10 missing data events); quality : 90 percent
*) 16 blinks filtered (16 missing data events); quality : 77 percent
*) 14 blinks filtered (14 missing data events); quality : 83 percent
*) 11 blinks filtered (11 missing data events); quality : 90 percent
*) 9 blinks filtered ( 9 missing data events); quality : 89 percent
*) 14 blinks filtered (14 missing data events); quality : 86 percent
*) 7 blinks filtered ( 8 missing data events); quality : 91 percent

99
PDToolkit/@PDSession/label.m Normal file
View File

@@ -0,0 +1,99 @@
function[obj] = label(obj, params)
%% extract labels from all MSG events
%% Step 1: read pattern from label_pattern (the varying part)
for p = 1:length(obj.label_patterns)
[token remainder] = strtok(obj.label_patterns{p},'%');
match{p} = strtrim(token);
if isempty(match{p})
match{p} = strtrim(strtok(remainder));
end
end
%% allocate only MSG events
msg_ind = regexp(obj.events_, 'MSG');
ind = find(~cellfun(@isempty,msg_ind));
l_ind = 1;
if (exist('match', 'var'))
for m = 1:length(match)
%% match all messages at once
s = regexp(obj.events_(ind), match{m});
m_ind = find(~cellfun(@isempty,s));
% m_ind now contains all events, that contain the match
for pe = 1:length(m_ind);
event_ind = ind(m_ind(pe));
label_timestamp= sscanf(obj.events_{event_ind},'%*s %d %*s');
pos = s{m_ind(pe)} + length(match{m});
obj.labels(l_ind).time = label_timestamp;
obj.labels(l_ind).label = strtrim(obj.events_{event_ind}(pos:end));
obj.labels(l_ind).match = match{m};
obj.labels(l_ind).type = 'normal';
obj.labels(l_ind).color = [0.4 0.4 0.4];
l_ind = l_ind + 1;
end
end
end
%% hook all matches up to stimuli
for t = 1:length(obj.trials)
trial = obj.trials(t);
%% in case no labels are defined, continue..
if (isempty(obj.labels))
continue;
end
for l = 1:length(obj.labels)
label_timestamps(l) = obj.labels(l).time(1);
end
% labels are set before or during
earlier_labels = find(label_timestamps < trial.trial_end);
later_labels = find(label_timestamps > trial.trial_start);
% variable is set during trial:
common = intersect(earlier_labels, later_labels);
if isempty(params.ForcePrecursorLabels)
params.ForcePrecursorLabels{2} = 0;
end
if (~params.ForcePrecursorLabels{2} && ~isempty(common))
trial.labels = obj.labels(common);
else
% no variables set during, perhaps a precursor variable?
if ~isempty(earlier_labels)
if t > 1
%% check later than previous trials
previous_trial = obj.trials(t-1);
later_than_previous = find(label_timestamps >= previous_trial.trial_end);
precursors = intersect(earlier_labels, later_than_previous);
trial.labels = obj.labels(precursors);
else
trial.labels = obj.labels(earlier_labels);
end
end
end
%% assign variables to trial in field 'type'
for l = 1:length(trial.labels)
varname = regexprep(trial.labels(l).match,'\s' ,'_');
trial.type.(varname) = trial.labels(l).label;
end
obj.trials(t) = trial;
end

11
PDToolkit/@PDSession/load.m Normal file
View File

@@ -0,0 +1,11 @@
function[obj] = loadData(obj)
if (exist(obj.datafile, 'file'))
obj.readASC
else
error(sprintf('File not found: %s', obj.datafile));
end

11
PDToolkit/@PDSession/loadData.m Normal file
View File

@@ -0,0 +1,11 @@
function[obj] = loadData(obj)
if (exist(obj.datafile, 'file'))
obj = obj.load_data_from_text;
else
error(sprintf('File not found: %s', obj.datafile));
end

86
PDToolkit/@PDSession/load_data_from_text.m Normal file
View File

@@ -0,0 +1,86 @@
function[obj] = load_data_from_text(obj )
%% load data from the .asc file
datafile = obj.datafile;
samples=[];
events ={};
load_processed_data = 0;
[base file ext] = fileparts(datafile);
target_dir = [base filesep file '.matlab'];
if (exist(target_dir, 'dir') == 0)
mkdir(target_dir);
end
cd(target_dir);
obj.display_and_log(['\tParsing file : ' file], 1);
obj.display_and_log(['\tDate : ' datestr(now)], 0);
target_raw = [target_dir filesep file '_raw.mat'];
target_processed = [target_dir filesep file '_processed.mat'];
if exist([target_dir filesep file '_processed.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_processed));
file_contents = load(target_processed);
data = file_contents.data;
load_processed_data = 1;
obj.events_ = data.events;
obj.samples = data.samples;
elseif exist([target_dir filesep file '_raw.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_raw));
file_contents= load(target_raw);
data = file_contents.data;
obj.events_ = data.events;
obj.samples = data.samples;
else
lc=0;
fp = fopen(datafile,'r');
i=1; j=1; m=1;
data_flag = 0;
[status lines_txt] = system(['wc ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
lines = str2num(lines_txt);
progressbar = waitbar(0, 'Reading data file...');
samples = nan(lines, 4);
while(~feof(fp))
if(mod(lc, 1000) ==0)
display(sprintf('working on line %5d', lc));
fprintf(repmat(sprintf('\b'),1,21));
waitbar(lc / lines, progressbar, sprintf('working on line %d', lc));
end
line=fgetl(fp);
if (data_flag & regexp(line, '^[0-9]*'))
samples(i,:) = sscanf(line, '%d %f %f %f');
i=i+1;
else
events{j} = line;
j=j+1;
end
if regexp(line,'^SAMPLES')
data_flag = 1;
end
lc=lc+1;
end
fclose(fp)
obj.samples = samples;
obj.events_ = events;
save(target_raw, 'obj');
close(progressbar);
end
%if ~load_processed_data
% [data] = preprocess_samples(data,settings);
%end

40
PDToolkit/@PDSession/mean.m Normal file
View File

@@ -0,0 +1,40 @@
function[mean] = mean(session, varargin)
%% options : '''Trials', [list of trials]}, ...
% '''Type'', {raw|interpolated|filtered}'
% '''BaselineCorrected''0/1'
% '''Marker'', marker id'
% '''Settings''' , settings object
params = struct('Trials', [], ...
'Type', 'none', ...
'BaselineCorrected', 1, ...
'Marker', 'stimulus onset',...
'Settings', []);
params = parseparams(varargin);
if isempty(params.Trials)
params.Trials = 1:length(sessions.trials);
end
if isstruct(params.Settings)
threshold = params.Settings.QualityThreshold;
quality_values = [ session.trials(Trials).quality ];
trials_to_kill = find(quality_values < threshold);
%exclude trials that fail the quality measure
params.Trials = setdiff(params.Trials, trials_to_kill);
end
for t = 1:length(params.Trials)
trial_id = params.Trials(t);
trial = session.trials(trial_id);
[times{t} traces{t}] = trial.getTrialDataShiftedForMarker(marker_id);
end
if nargin == 1

33
PDToolkit/@PDSession/patternBuilder.m Normal file
View File

@@ -0,0 +1,33 @@
function[session] = patternBuilder(session)
pbfig = figure;
pbevents = figure;
jList = java.util.ArrayList;
j=0;
for i = 1:length(session.events_)
if (strmatch('MSG', session.events_{i}))
jList.add(j,['<html><font name="Verdana" size=1><b>' session.events_{i} '</b></font></html>']);
j=j+1;
end
end
jCBList = com.mathworks.mwswing.checkboxlist.CheckBoxList(jList);
jScrollPane = com.mathworks.mwswing.MJScrollPane(jCBList);
posfig = get(gcf, 'Position');
posfig(1) = 0;
set(pbevents, 'Position', posfig);
posfig(1) = posfig(3)+10;
set(pbfig, 'Position' , posfig);
[jhCBList,hContainer] = javacomponent(jScrollPane,[20,20,posfig(3)-40,posfig(4)-40],gcf);
set(jCBList, 'ValueChangedCallback', @session.plotTrialBasedonPattern);
set(jCBList, 'Tag', 'msg_events');
jCBModel = jCBList.getCheckModel;
jCBModel.uncheckAll;
jCBModel.checkIndex(1);
get(jCBList, 'Tag')

14
PDToolkit/@PDSession/plotTrialBasedonPattern.m Normal file
View File

@@ -0,0 +1,14 @@
function[session] = plotTrialBasedonPattern(varargin)
jListBox = varargin{1};
jEventData = varargin{2};
hListbox = varargin{3};
jCBModel = get(jEventData, 'CheckModel');
numChecks = jCBModel.getCheckedCount;
activeIndex = get(hListbox, 'SelectedIndex');
if (numChecks > 2)
jCBModel.uncheckAll;
jcBModel.checkIndex(activeIndex);
end

22
PDToolkit/@PDSession/preprocess.m Normal file
View File

@@ -0,0 +1,22 @@
function[obj] = preprocess(obj, settings)
if strcmp(settings.Preprocessing.Type, 'trial')
for t = 1:length(obj.trials)
obj.trials(t) = obj.trials(t).preprocess(settings);
end
else
%% Session based preprocessing
obj = obj.remove_blinks(settings);
% Smooth the data
obj = obj.smooth(settings);
% Calculate logtransformed data
obj = obj.logtransform;
for t = 1:length(obj.trials)
obj.trials(t) = obj.trials(t).correct_for_baseline(settings);
obj.trials(t) = obj.trials(t).calculate_statistics;
end
end

101
PDToolkit/@PDSession/read_ASC.m Normal file
View File

@@ -0,0 +1,101 @@
function[obj] = read_ASC(obj)
%% low level function to read in asc data from Eyelink eyetracker data
datafile = obj.datafile;
samples=[];
events ={};
load_processed_data = 0;
eye = 'left'; %% default assume left eye
[base file ext] = fileparts(datafile);
target_dir = [base filesep file '.matlab'];
if (exist(target_dir, 'dir') == 0)
mkdir(target_dir);
end
cd(target_dir);
display(['Parsing file : ' file]);
%display_and_log(['Parsing file : ' file], 1);
%display_and_log(['Date : ' datestr(now)], 0);
target_raw = [target_dir filesep file '_raw.mat'];
target_processed = [target_dir filesep file '_processed.mat'];
settings.target_raw = target_raw;
settings.target_processed = target_processed;
if exist([target_dir filesep file '_processed.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_processed));
file_contents = load(target_processed);
obj = file_contents.obj;
%data = file_contents.data;
load_processed_data = 1;
elseif exist([target_dir filesep file '_raw.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_raw));
file_contents= load(target_raw);
data = file_contents.data;
else
lc=0;
fp = fopen(datafile,'r');
i=1; j=1; m=1;
data_flag = 0;
if (isunix)
cmd = ['wc ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}'];
cmd = regexprep(cmd,'\(', '\\('); cmd = regexprep(cmd,'\)', '\\)');
[status lines_txt] = system(cmd);
[status events_txt] = system(['grep -c "^[0-9*" ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
else
[status lines_txt] = system(['find /c ' datafile]);
end
lines = str2num(lines_txt);
nevents = str2num(events_txt);
progressbar = waitbar(0, 'Reading data file...');
samples = nan(lines, 4);
events = cell(1, nevents);
while(~feof(fp))
if(mod(lc, 1000) ==0)
% display(sprintf('working on line %d', lc));
waitbar(lc / lines, progressbar, sprintf('Reading data file ... : %d %%', round(100*(lc / lines))));
end
line=fgetl(fp);
if (data_flag & regexp(line, '^[0-9]*'))
samples(i,:) = sscanf(line, '%d %f %f %f %*s');
i=i+1;
else
events{j} = line;
j=j+1;
end
if regexp(line,'^SAMPLES')
data_flag = 1;
end
if regexp(line,'^START')
eye = sscanf(line, '%*s %*s %s %*s');
end
lc=lc+1;
end
fclose(fp);
data.samples = samples;
data.events = events;
data.eye = lower(eye);
save(target_raw, 'data');
close(progressbar);
end

93
PDToolkit/@PDSession/read_gazedata.m Normal file
View File

@@ -0,0 +1,93 @@
function[obj] = readASC(obj)
%% low level function to read in asc data from Tobii eyetracker data
datafile = obj.datafile;
samples=[];
events ={};
load_processed_data = 0;
[base file ext] = fileparts(datafile);
target_dir = [base filesep file '.matlab'];
if (exist(target_dir, 'dir') == 0)
mkdir(target_dir);
end
cd(target_dir);
display(['Parsing file : ' file]);
%display_and_log(['Parsing file : ' file], 1);
%display_and_log(['Date : ' datestr(now)], 0);
target_raw = [target_dir filesep file '_raw.mat'];
target_processed = [target_dir filesep file '_processed.mat'];
settings.target_raw = target_raw;
settings.target_processed = target_processed;
if exist([target_dir filesep file '_processed.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_processed));
file_contents = load(target_processed);
data = file_contents.data;
load_processed_data = 1;
elseif exist([target_dir filesep file '_raw.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_raw));
file_contents= load(target_raw);
data = file_contents.data;
else
lc=0;
fp = fopen(datafile,'r');
i=1; j=1; m=1;
data_flag = 0;
if (isunix)
[status lines_txt] = system(['wc ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
[status events_txt] = system(['grep -c "^[0-9*" ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
else
[status lines_txt] = system(['find /c ' datafile]);
end
lines = str2num(lines_txt);
nevents = str2num(events_txt);
progressbar = waitbar(0, 'Reading data file...');
samples = nan(lines, 4);
events = cell(1, nevents);
header =fgetl(fp);
params = strsplit(header, '\t');
pupil_params = find(~cellfun(@isempty,strfind(params, 'Pupil')));
while(~feof(fp))
if(mod(lc, 1000) ==0)
% display(sprintf('working on line %d', lc));
waitbar(lc / lines, progressbar, sprintf('Reading data file ... : (%f)', round(100*(lc / lines))));
end
line=fgetl(fp);
pattern = ['%*d %*d %*d %d ' repmat('%*f ', 1, pupil_params(1)-5) '%f %*s']
if (data_flag & regexp(line, '^[0-9]*'))
samples(i,:) = sscanf(line, '%*d %*d %*d %d %f %*s');
i=i+1;
else
events{j} = line;
j=j+1;
end
if regexp(line,'^SAMPLES')
data_flag = 1;
end
lc=lc+1;
end
fclose(fp)
data.samples = samples;
data.events = events;
save(target_raw, 'data');
close(progressbar);
end

94
PDToolkit/@PDSession/read_gazedata.m~ Normal file
View File

@@ -0,0 +1,94 @@
function[obj] = readASC(obj)
%% low level function to read in asc data from Tobii eyetracker data
datafile = obj.datafile;
samples=[];
events ={};
load_processed_data = 0;
[base file ext] = fileparts(datafile);
target_dir = [base filesep file '.matlab'];
if (exist(target_dir, 'dir') == 0)
mkdir(target_dir);
end
cd(target_dir);
display(['Parsing file : ' file]);
%display_and_log(['Parsing file : ' file], 1);
%display_and_log(['Date : ' datestr(now)], 0);
target_raw = [target_dir filesep file '_raw.mat'];
target_processed = [target_dir filesep file '_processed.mat'];
settings.target_raw = target_raw;
settings.target_processed = target_processed;
if exist([target_dir filesep file '_processed.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_processed));
file_contents = load(target_processed);
data = file_contents.data;
load_processed_data = 1;
elseif exist([target_dir filesep file '_raw.mat'], 'file');
display(sprintf('*) Loading data from file : %s', target_raw));
file_contents= load(target_raw);
data = file_contents.data;
else
lc=0;
fp = fopen(datafile,'r');
i=1; j=1; m=1;
data_flag = 0;
if (isunix)
[status lines_txt] = system(['wc ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
[status events_txt] = system(['grep -c "^[0-9*" ' regexprep(datafile,' ', '\\ ') '|awk ''{print $1''}']);
else
[status lines_txt] = system(['find /c ' datafile]);
end
lines = str2num(lines_txt);
nevents = str2num(events_txt);
progressbar = waitbar(0, 'Reading data file...');
samples = nan(lines, 4);
events = cell(1, nevents);
header =fgetl(fp);
params = strsplit(header, '\t');
pupil_params = strfind(param
while(~feof(fp))
if(mod(lc, 1000) ==0)
% display(sprintf('working on line %d', lc));
waitbar(lc / lines, progressbar, sprintf('Reading data file ... : (%f)', round(100*(lc / lines))));
end
line=fgetl(fp);
if (data_flag & regexp(line, '^[0-9]*'))
samples(i,:) = sscanf(line, '%d %f %f %f %*s');
i=i+1;
else
events{j} = line;
j=j+1;
end
if regexp(line,'^SAMPLES')
data_flag = 1;
end
lc=lc+1;
end
fclose(fp)
data.samples = samples;
data.events = events;
save(target_raw, 'data');
close(progressbar);
end

234
PDToolkit/@PDSession/rebuild.m Normal file
View File

@@ -0,0 +1,234 @@
function[objs] = rebuild(objs, params);
%% PDSession.rebuild
%
% based on patterns parse the datafile and create trials
%
i=1; i1=1;i2=1;i3=1;
progressbar = waitbar(0, 'Parsing trial data...','Visible', 'off');
p= get(progressbar, 'Position'); p(2)=p(2)+100;
set(progressbar,'Position', p, 'Color', [1 1 1]);
t = get(get(progressbar, 'Children'), 'Title');
set(t, 'FontSize', 15, 'FontWeight', 'bold', 'FontName', 'Tahoma');
set(progressbar,'Visible','on');
for o = 1:length(objs)
obj = objs(o);
new_trial = PDTrial;
obj = obj.check_patterns;
dependencies.trial_start= [];
dependencies.trial_end = [];
dependencies.baseline_onset = [];
dependencies.baseline_offset = [];
dependencies.stimulus_onset = [];
dependencies.stimulus_offset = [];
%% fill in all relative pattern timings :
%% TODO : add previous relative items inhere
if iscell(obj.trial_start_pattern),
ind = length(dependencies);
eval(['dependencies.' obj.trial_start_pattern{2} ' = {''trial_start'' ' num2str(obj.trial_start_pattern{1}) '};']);
end
if iscell(obj.trial_end_pattern),
ind = length(dependencies);
eval(['dependencies.' obj.trial_end_pattern{2} '{' num2str(ind) '} = {''trial_end'' ' num2str(obj.trial_end_pattern{1}) '};']);
end
if iscell(obj.baseline_onset_pattern),
%display('Dependency found for baseline onset pattern');
eval(['ind = size(dependencies.' obj.baseline_onset_pattern{2} ', 2) +1;']);
eval(['dependencies.' obj.baseline_onset_pattern{2} '{' num2str(ind) '} = {''baseline_onset'' ' num2str(obj.baseline_onset_pattern{1}) '};']);
end
if iscell(obj.baseline_offset_pattern),
%display('Dependency found for baseline offset pattern');
eval(['ind = size(dependencies.' obj.baseline_offset_pattern{2} ', 2) +1;']);
eval(['dependencies.' obj.baseline_offset_pattern{2} '{' num2str(ind) '} = {''baseline_offset'' ' num2str(obj.baseline_offset_pattern{1}) '};']);
end
if iscell(obj.stimulus_onset_pattern),
eval(['ind = size(dependencies.' obj.stimulus_onset_pattern{2} ', 2) +1;']);
eval(['dependencies.' obj.stimulus_onset_pattern{2} '{' num2str(ind) '} = {''stimulus_onset'' ' num2str(obj.stimulus_onset_pattern{1}) '};']);
end
if iscell(obj.stimulus_offset_pattern),
eval(['ind = size(dependencies.' obj.stimulus_offset_pattern{2} ', 2) +1;']);
eval(['dependencies.' obj.stimulus_offset_pattern{2} '{' num2str(ind) '} = {''stimulus_offset'' ' num2str(obj.stimulus_offset_pattern{1}) '};']);
end
%% go through all events
msg_indices = strmatch('MSG',obj.events_);
%% these checks can be performed outside of the for-loop
itsp = ischar(obj.trial_start_pattern);
itep = ischar(obj.trial_end_pattern);
ibon = ischar(obj.baseline_onset_pattern);
ibof = ischar(obj.baseline_offset_pattern);
ison = ischar(obj.stimulus_onset_pattern);
isof = ischar(obj.stimulus_offset_pattern);
dep_ts = ~isempty(dependencies.trial_start);
dep_te = ~isempty(dependencies.trial_end);
dep_bon = ~isempty(dependencies.baseline_onset);
dep_bof = ~isempty(dependencies.baseline_offset);
dep_son = ~isempty(dependencies.stimulus_onset);
dep_sof = ~isempty(dependencies.stimulus_offset);
ii=1;
for e_i = 1:length(msg_indices) %1:length(obj.events_)
e = msg_indices(e_i);
%% a new trial marker has been found
if (itsp && ~isempty(regexp(obj.events_{e}, obj.trial_start_pattern)))
%% if trial_start has been set, a new trial starts
if ~isempty(new_trial.trial_start)
%% reset trial_end to new trial_start
if (strcmp(obj.trial_start_pattern, obj.trial_end_pattern) == 1)
time = sscanf(obj.events_{e},'%*s %d %*s %*s');
new_trial.trial_end = time(1);
end
trial_samples = intersect(find(obj.samples(:,1) > new_trial.trial_start), ...
find(obj.samples(:,1) < new_trial.trial_end));
new_trial.time = obj.samples(trial_samples, 1);
new_trial.data.(obj.eye).uncorrected.raw = obj.samples(trial_samples, 4);
obj.trials(i) = new_trial;
new_trial = PDTrial;
i=i+1;
if (mod(i,10)==0) % updating waitbar is very time consuming
waitbar(e_i/length(msg_indices), progressbar, sprintf('Session: %s - Parsing data for trial %d...', obj.name, i));
end
end
%% no previous trial was defined
time = sscanf(obj.events_{e},'%*s %d %*s %*s');
new_trial.trial_start = time(1); %% disregard optional numbers in the message
if dep_ts
for db = 1:length(dependencies.trial_start)
dependency = dependencies.trial_start{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.trial_start) ' + ' num2str(dependency{2}) ';']);
end
end
end
%% a new baseline marker (onset) has been found
if (ibon && ~isempty(regexp(obj.events_{e}, obj.baseline_onset_pattern)))
new_trial.baseline_onset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_bon
for db = 1:length(dependencies.baseline_onset)
dependency = dependencies.baseline_onset{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.baseline_onset) ' + ' num2str(dependency{2}) ';']);
end
end
end
%% a new baseline marker (offset) has been found
if (ibof && ~isempty(regexp(obj.events_{e}, obj.baseline_offset_pattern)))
new_trial.baseline_offset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_bof
for db = 1:length(dependencies.baseline_offset)
dependency = dependencies.baseline_offset{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.baseline_offset) ' + ' num2str(dependency{2}) ';']);
end
end
end
%% a new stimulus onset marker has been found
if (ison && ~isempty(regexp(obj.events_{e}, obj.stimulus_onset_pattern)))
new_trial.stimulus_onset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_son
for db = 1:length(dependencies.stimulus_onset)
dependency = dependencies.stimulus_onset{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.stimulus_onset) ' + ' num2str(dependency{2}) ';']);
end
end
end
%% a new stimulus offset marker has been found
if (isof && ~isempty(regexp(obj.events_{e}, obj.stimulus_offset_pattern)))
new_trial.stimulus_offset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_sof
for db = 1:length(dependencies.stimulus_offset)
dependency = dependencies.stiulus_offset{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.stimulus_offset) ' + ' num2str(dependency{2}) ';']);
end
end
end
%% a new trial end marker has been found
if ~isempty(new_trial.trial_end)
else
%% if trial_start == trial_end matching, skip the current line
if (strcmp(obj.trial_start_pattern, obj.trial_end_pattern) == 1)
continue;
end
if (itep && ~isempty(regexp(obj.events_{e}, obj.trial_end_pattern)))
end_time = sscanf(obj.events_{e},'%*s %d %*s %*s');
new_trial.trial_end = end_time(1); % disregard numbers in message
if dep_te
for db = 1:length(dependencies.trial_end)
dependency = dependencies.trial_end{db};
eval(['new_trial.' dependency{1} ' = ' num2str(new_trial.trial_end) ' + ' num2str(dependency{2}) ';']);
end
end
if (isempty(new_trial.trial_start))
warning('Trial end detected, but no previous Trial start has been found : skipping trial');
end
%% [trialdata_i quality_i qc_i blink_list_i] = preprocess_trial(data.samples(total_trial_ind,:), settings, sprintf('Trial %2d',i));
end
end
end
%% add the final trial
if (~isempty(new_trial.trial_start) & ~isempty(new_trial.trial_end))
trial_samples = intersect(find(obj.samples(:,1) > new_trial.trial_start), ...
find(obj.samples(:,1) < new_trial.trial_end));
new_trial.time = obj.samples(trial_samples, 1);
new_trial.data.(obj.eye).uncorrected.raw = obj.samples(trial_samples, 4);
obj.trials(i) = new_trial;
end
close(progressbar);
obj = label(obj, params);
% data.trialdata.indices = trial_indices;
% data.trialdata.indices_description = {'Fixation6s starting','Stimulus Presentation','Fixation15s starting','Fixation15s ending'};
% data.baseline.start = baseline_start;
% data.baseline.end = baseline_end;
% baseline = [];
% for b = 1: length(data.baseline.data)
% baseline = [baseline data.baseline.data{b}];
% end
% cumulative = cumsum(hist(baseline, 10000));
%%turning_points = find(diff(cumulative) > 1000);
%%data.baseline.cumulative = cumulative;
%%data.baseline.mean = mean(data.baseline.cumulative(1:turning_points(1)));
objs(o) = obj;
end

269
PDToolkit/@PDSession/rebuildMulti.m Normal file
View File

@@ -0,0 +1,269 @@
function[obj] = rebuildMulti(obj);
%% assertions:
i=1; i1=1;i2=1;i3=1;
progressbar = waitbar(0, 'Parsing trial data...','Visible', 'off');
p= get(progressbar, 'Position'); p(2)=p(2)+100;
set(progressbar,'Position', p, 'Color', [1 1 1]);
t = get(get(progressbar, 'Children'), 'Title');
set(t, 'FontSize', 15, 'FontWeight', 'bold', 'FontName', 'Tahoma');
set(progressbar,'Visible','on');
new_trial = PDTrial;
obj = obj.check_patterns;
dependencies.trial_start= [];
dependencies.trial_end = [];
dependencies.baseline_onset = [];
dependencies.baseline_offset = [];
dependencies.stimulus_onset = [];
dependencies.stimulus_offset = [];
current_pattern.trial_start_pattern = 1;
current_pattern.trial_end_pattern = 1;
current_pattern.stimulus_onset_pattern = 1;
current_pattern.stimulus_offset_pattern = 1;
current_pattern.baseline_onset_pattern = 1;
current_pattern.baseline_offset_pattern = 1;
%% fill in all relative pattern timings :
for i = 1:length(obj.trial_start_pattern)
if iscell(obj.trial_start_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.trial_start_pattern(i).pattern{2} ' = {''trial_start'' ' num2str(obj.trial_start_pattern(i).pattern{1}) '};']);
end
end
for i = 1:length(obj.trial_end_pattern)
if iscell(obj.trial_end_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.trial_end_pattern(i).pattern{2} ' = {''trial_end'' ' num2str(obj.trial_end_pattern(i).pattern{1}) '};']);
end
end
for i = 1:length(obj.baseline_onset_pattern)
if iscell(obj.baseline_onset_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.baseline_onset_pattern(i).pattern{2} ' = {''baseline_onset'' ' num2str(obj.baseline_onset_pattern(i).pattern{1}) '};']);
end
end
for i = 1:length(obj.baseline_offset_pattern)
if iscell(obj.baseline_offset_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.baseline_offset_pattern(i).pattern{2} ' = {''baseline_offset'' ' num2str(obj.baseline_offset_pattern(i).pattern{1}) '};']);
end
end
for i = 1:length(obj.stimulus_onset_pattern)
if iscell(obj.stimulus_onset_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.stimulus_onset_pattern(i).pattern{2} ' = {''stimulus_onset'' ' num2str(obj.stimulus_onset_pattern(i).pattern{1}) '};']);
end
end
for i = 1:length(obj.stimulus_offset_pattern)
if iscell(obj.stimulus_offset_pattern(i).pattern),
eval(['dependencies(' num2str(i) ').' obj.stimulus_offset_pattern(i).pattern{2} ' = {''stimulus_onset'' ' num2str(obj.stimulus_offset_pattern(i).pattern{1}) '};']);
end
end
%% go through all events
msg_indices = strmatch('MSG',obj.events_);
% tmp = sscanf(obj.events_{e}, '%*s %d %*s');
% data.msg_events(i,1) = tmp(1);
% data.msg_events(i,2) = e;
% i3=i3+1;
% end
%% these checks can be performed outside of the for-loop
itsp = ischar(obj.trial_start_pattern(current_pattern.trial_start).pattern);
itep = ischar(obj.trial_end_pattern(current_pattern.trial_end).pattern;
ibon = ischar(obj.baseline_onset_pattern(current_pattern.baseline_onest).pattern;
ibof = ischar(obj.baseline_offset_pattern(current_pattern.baseline_offset).pattern;
ison = ischar(obj.stimulus_onset_pattern(current_pattern.stimulus_onset).pattern);
isof = ischar(obj.stimulus_offset_pattern(current_pattern.stimulus_offset).pattern);
dep_ts = ~isempty(dependencies(current_pattern.trial_start).trial_start);
dep_te = ~isempty(dependencies(current_pattern.trial_end).trial_end);
dep_bon = ~isempty(dependencies(current_pattern.baseline_onset).baseline_onset);
dep_bof = ~isempty(dependencies(current_pattern.baseline_offset).baseline_offset);
dep_son = ~isempty(dependencies(current_pattern.stimulus_onset).stimulus_onset);
dep_sof = ~isempty(dependencies(current_pattern.stimulus_offset).stimulus_offset);
ii=1;
previous_trial_e_i = 1;
%for e_i = 1:length(msg_indices) %1:length(obj.events_)
while e_i <= length(msg_indices);
e = msg_indices(e_i);
%% a new trial marker has been found
if (itsp && ~isempty(regexp(obj.events_{e}, obj.trial_start_pattern(current_pattern.trial_start).pattern)))
rescan_trial = 0;
if isempty(new_trial.trial_end)
current_pattern.trial_end = current_pattern.trial_end + 1;
itsp = ischar(obj.trial_start_pattern(current_pattern.trial_start).pattern);
dep_ts = ~isempty(dependencies(current_pattern.trial_start).trial_start);
if current_pattern.trial_end <= length(obj.trial_start_pattern)
rescan_trial = 1;
end
end
if isempty(new_trial.stimulus_onset)
current_pattern.stimulus_onset = current_pattern.stimulus_onset + 1;
ison = ischar(obj.stimulus_onset_pattern(current_pattern.stimulus_onset).pattern);
dep_son = ~isempty(dependencies(current_pattern.stimulus_onset).stimulus_onset);
if current_pattern.stimulus_onset <= length(obj.stimulus_onset_pattern)
rescan_trial = 1;
end
end
if isempty(new_trial.stimulus_offset)
current_pattern.stimulus_offset = current_pattern.stimulus_offset + 1;
isof = ischar(obj.stimulus_offset_pattern(current_pattern.stimulus_offset).pattern);
dep_sof = ~isempty(dependencies(current_pattern.stimulus_offset).stimulus_offset);
if current_pattern.stimulus_offset <= length(obj.stimulus_offset_pattern)
rescan_trial = 1;
end
end
if isempty(new_trial.baseline_offset)
current_pattern.baseline_offset = current_pattern.baseline_offset + 1;
ibof = ischar(obj.baseline_offset_pattern(current_pattern.baseline_offset).pattern;
dep_bof = ~isempty(dependencies(current_pattern.baseline_offset).baseline_offset
if current_pattern.baseline_offset <= length(obj.baseline_offset_pattern)
rescan_trial = 1;
end
end
if isempty(new_trial.baseline_onset)
current_pattern.baseline_onset = current_pattern.baseline_onset + 1;
ibon = ischar(obj.baseline_onset_pattern(current_pattern.baseline_onest).pattern;
dep_bof = ~isempty(dependencies(current_pattern.baseline_offset).baseline_offset);
if current_pattern.baseline_onset <= length(obj.baseline_onset_pattern)
rescan_trial = 1;
end
end
if (rescan_trial)
e_i = previous_trial_e_i;
continue;
end
%% if trial_start has been set, a new trial starts
if ~isempty(new_trial.trial_start)
trial_samples = intersect(find(obj.samples(:,1) > new_trial.trial_start), ...
find(obj.samples(:,1) < new_trial.trial_end));
new_trial.time = obj.samples(trial_samples, 1);
new_trial.data.uncorrected.raw = obj.samples(trial_samples, 4);
obj.trials(i) = new_trial;
new_trial = PDTrial;
previous_trial_e_i = e_i;
i=i+1;
if (mod(i,10)==0) % updating waitbar is very time consuming
waitbar(e_i/length(msg_indices), progressbar, sprintf('Session: %s - Parsing data for trial %d...', obj.name, i));
end
end
new_trial.trial_start = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_ts
eval(['new_trial.' dependencies(current_pattern.trial_start).trial_start{1} ' = ' num2str(new_trial.trial_start) ' + ' num2str(dependencies(current_pattern.trial_start).trial_start{2}) ';']);
end
end
%% a new baseline marker (offset) has been found
if (ibon && ~isempty(regexp(obj.events_{e}, obj.baseline_onset_pattern(current_pattern.baseline_onset).pattern)))
new_trial.baseline_onset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_bon
eval(['new_trial.' dependencies(current_pattern.baseline_onset).baseline_onset{1} ' = ' num2str(new_trial.baseline_onset) ' + ' num2str(dependencies(current_pattern.baseline_onset).baseline_onset{2}) ';']);
end
end
%% a new baseline marker (offset) has been found
if (ibof && ~isempty(regexp(obj.events_{e}, obj.baseline_offset_pattern(current_pattern.baseline_offset).pattern)))
new_trial.baseline_offset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_bof
eval(['new_trial.' dependencies((current_pattern.baseline_onset).baseline_offset{1} ' = ' num2str(new_trial.baseline_offset) ' + ' num2str(dependencies(current_pattern.baseline_onset).baseline_offset{2}) ';']);
end
end
%% a new stimulus onset marker has been found
if (ison && ~isempty(regexp(obj.events_{e}, obj.stimulus_onset_pattern(current_pattern.stimulus_onset).pattern)))
new_trial.stimulus_onset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_son
eval(['new_trial.' dependencies(current_pattern.stimulus_onset).stimulus_onset{1} ' = ' num2str(new_trial.stimulus_onset) ' + ' num2str(dependencies(current_pattern.stimulus_onset).stimulus_onset{2}) ';']);
end
end
%% a new stimulus offset marker has been found
if (isof && ~isempty(regexp(obj.events_{e}, obj.stimulus_offset_pattern(current_pattern.stimulus_offset).pattern)))
new_trial.stimulus_offset = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_bof
eval(['new_trial.' dependencies(current_pattern.stimulus_offset).stimulus_offset{1} ' = ' num2str(new_trial.stimulus_offset) ' + ' num2str(dependencies(current_pattern.stimulus_offset).stimulus_offset{2}) ';']);
end
end
%% a new trial end marker has been found
if ~isempty(new_trial.trial_end)
else
if (itep && ~isempty(regexp(obj.events_{e}, obj.trial_end_pattern(current_pattern.trial_end).pattern)))
new_trial.trial_end = sscanf(obj.events_{e},'%*s %d %*s %*s');
if dep_te
eval(['new_trial.' dependencies(current_pattern.trial_end).trial_end ' = ' num2str(new_trial.time) ' + ' num2str(dependencies(current_pattern.trial_end).trial_end{2}) ';']);
end
if (isempty(new_trial.trial_start))
warning('Trial end detected, but no previous Trial start has been found : skipping trial');
end
%% [trialdata_i quality_i qc_i blink_list_i] = preprocess_trial(data.samples(total_trial_ind,:), settings, sprintf('Trial %2d',i));
end
end
end
%% add the final trial
trial_samples = intersect(find(obj.samples(:,1) > new_trial.trial_start), ...
find(obj.samples(:,1) < new_trial.trial_end));
new_trial.time = obj.samples(trial_samples, 1);
new_trial.data.uncorrected.raw = obj.samples(trial_samples, 4);
obj.trials(i) = new_trial;
close(progressbar);
obj = label(obj);
% data.trialdata.indices = trial_indices;
% data.trialdata.indices_description = {'Fixation6s starting','Stimulus Presentation','Fixation15s starting','Fixation15s ending'};
% data.baseline.start = baseline_start;
% data.baseline.end = baseline_end;
% baseline = [];
% for b = 1: length(data.baseline.data)
% baseline = [baseline data.baseline.data{b}];
% end
% cumulative = cumsum(hist(baseline, 10000));
%%turning_points = find(diff(cumulative) > 1000);
%%data.baseline.cumulative = cumulative;
%%data.baseline.mean = mean(data.baseline.cumulative(1:turning_points(1)));

6
PDToolkit/@PDSession/removeDuplicateLabels.m Normal file
View File

@@ -0,0 +1,6 @@
function[obj] = removeDuplicateLabels(obj)
for t = 1:length(obj.trials)
obj.trials(t) = obj.trials(t).removeDuplicateLabels;
end

76
PDToolkit/@PDSession/remove_blinks.m Normal file
View File

@@ -0,0 +1,76 @@
fun
tion[obj] = remove_blinks(obj, settings)
%% session based removal of blinks
data_column = 4;
eyes = fieldnames(obj.data);
for e = 1:length(eyes)
eye = eyes{e};
signal = obj.data.(eye).uncorrected.raw;
%no data available for eye
if isempty(signal)
continue
end
%% Kill the missing datapoints
missing = find(obj.time == signal);
signal(missing) = NaN;
%% store original signal for reference
obj.data.(eye).uncorrected.raw = signal;
obj.blink_count.(eye) = 0;
obj.missing_data_count.(eye) = 0;
%% Kill the blinks (pupil dilation dip)
nans = find(isnan(signal));
%% Count the NaNs before extending them.
nans=find(isnan(signal));
dnans = diff(nans);
missing_data_list = find(dnans>1);
missing_data_count = 0;
if ~isempty(missing_data_list)
blink_list(:,1) = nans(missing_data_list);
blink_list(:,2) = dnans(missing_data_list);
blink_list(:,3) = dnans(missing_data_list) < settings.MaximumBlinkSize;
obj.blink_count.(eye) = length(find(blink_list(:,3)));
obj.missing_data_count.(eye) = length(missing_data_list);
obj.blinks.(eye) = blink_list;
end
%% Extend the NaNs
for n = 1:length(nans)
window = [nans(n)-settings.BlinkExtension(1):nans(n)+settings.BlinkExtension(2)];
window(find(window<1)) = []; %% kill the negative indices for early blinks
signal(window) = NaN;
end
if isempty(obj.blink_count.(eye))
obj.blink_count.(eye) = 0;
end
if isempty(obj.missing_data_count.(eye))
obj.missing_data_count.(eye) = 0;
end
%% determine quality;
obj.quality.(eye) = 100 - (length(find(isnan(signal))) / length(signal)*100);
obj.valid = 1;
if (obj.quality.(eye) < settings.QualityThreshold)
obj.display_and_log(sprintf('\t*) %2d blinks filtered (%2d missing data events); quality : %2d percent -> Trial excluded\n', obj.blink_count.(eye), obj.missing_data_count.(eye),round(obj.quality.(eye))));
obj.valid.(eye) = 0;
else
obj.display_and_log(sprintf('\t*) %2d blinks filtered (%2d missing data events); quality : %2d percent', obj.blink_count.(eye), obj.missing_data_count.(eye),round(obj.quality.(eye))));
end
%% Interpolate NaNs
signal= obj.inpaint_nans(signal);
obj.data.(eye).uncorrected.interpolated = signal;
end

100
PDToolkit/@PDSession/setFailSafePatternRelativeToPattern.m Normal file
View File

@@ -0,0 +1,100 @@
function[obj] = setFailSafePatternRelativeToPattern(obj, relativeTotype,type, timing)
%% Specify a new marker/pattern relative in time to an existing pattern
% time should be milliseconds (ms).
if ~isnumeric(timing)
error('Timing is not numeric');
end
ton_codings = {'trial onset','trial on', 'start trial', 'trial start', 'trial_start'};
toff_codings = {'trial offset','trial off', 'end trial', 'trial end', 'trial_end'};
son_codings = {'stimulus onset','stimulus on', 'soa', 'stim on', 'stim_on'};
soff_codings = {'stimulus offset','stimulus off', 'stim off', 'stim_off'};
bon_codings = {'baseline on', 'baseline start', 'baseline onset', 'bl on', 'bl'};
boff_codings = {'baseline off', 'baseline end', 'baseline offset', 'bl off'};
%% check whether the type exists, otherwise no failsafe is possible
ton = ismember(lower(type), ton_codings);
toff = ismember(lower(type), toff_codings);
son = ismember(lower(type), son_codings);
soff = ismember(lower(type), soff_codings);
bon = ismember(lower(type), bon_codings);
boff = ismember(lower(type), boff_codings);
type_list = [ton toff son soff bon boff];
existing_type_ind = find(type_list==1);
if isempty(existing_type_ind)
error('No correct type entered');
else
err=0;
switch typeexisting_type_ind_ind
case 1
if (isempty(obj.trial_start_pattern)), err=1; else target = 'trial_start'; end
case 2
if (isempty(obj.trial_end_pattern)), err=1; else target = 'trial_end'; end
case 3
if (isempty(obj.stimulus_onset_pattern)), err=1; else target = 'stimulus_onset'; end
case 4
if (isempty(obj.stimulus_offset_pattern)), err=1; else target = 'stimulus_offset'; end
case 5
if (isempty(obj.baseline_onset_pattern)), err=1; else target = 'baseline_onset'; end
case 6
if (isempty(obj.baseline_offset_pattern)), err=1; else target = 'baseline_offset'; end
end
end
if err
error('Failsafe for empty type is not allowed');
end
%% check for valid relativeTotype
ton = ismember(lower(relativeTotype), ton_codings);
toff = ismember(lower(relativeTotype), toff_codings);
son = ismember(lower(relativeTotype), son_codings);
soff = ismember(lower(relativeTotype), soff_codings);
bon = ismember(lower(relativeTotype), bon_codings);
boff = ismember(lower(relativeTotype), boff_codings);
types = [ton toff son soff bon boff];
type_ind = find(types==1);
if isempty(type_ind)
error('No correct type entered');
else
err=0;
switch type_ind
case 1
if (isempty(obj.trial_start_pattern)), err=1; else target = 'trial_start'; end
case 2
if (isempty(obj.trial_end_pattern)), err=1; else target = 'trial_end'; end
case 3
if (isempty(obj.stimulus_onset_pattern)), err=1; else target = 'stimulus_onset'; end
case 4
if (isempty(obj.stimulus_offset_pattern)), err=1; else target = 'stimulus_offset'; end
case 5
if (isempty(obj.baseline_onset_pattern)), err=1; else target = 'baseline_onset'; end
case 6
if (isempty(obj.baseline_offset_pattern)), err=1; else target = 'baseline_offset'; end
end
end
if err
error('Dependent type has not been defined');
end
if (ismember(lower(type), ton_codings)) obj.trial_start_pattern = {timing target}; end
if (ismember(lower(type), toff_codings)) obj.trial_end_pattern = {timing target}; end
if (ismember(lower(type), son_codings)) obj.stimulus_onset_pattern = {timing target}; end
if (ismember(lower(type), soff_codings)) obj.stimulus_onset_pattern = {timing target}; end
if (ismember(lower(type), bon_codings)) obj.baseline_onset_pattern = {timing target}; end
if (ismember(lower(type), boff_codings)) obj.baseline_offset_pattern = {timing target}; end

16
PDToolkit/@PDSession/setFramerate.m Normal file
View File

@@ -0,0 +1,16 @@
function[obj] = setFramerate(obj)
if exist(obj.datafile, 'file')
datafile = regexprep(obj.datafile, ' ','\\ ');
[status sampling_rate_str] = system(['grep FRAMERATE ' datafile '|awk ''{print $4}''']);
if ischar(sampling_rate_str)
obj.sampling_rate = str2num(sampling_rate_str);
end
%% display(sprintf('\t\tFramerate : %3.2f Hz', obj.sampling_rate));
end

35
PDToolkit/@PDSession/setLabel.m Normal file
View File

@@ -0,0 +1,35 @@
function[objs] = setLabel(objs, pattern)
%% define possible coding styles of markers
if (~ischar(pattern))
error('Pattern must be character array')
end
%% check for existing patterns
for o = 1:length(objs)
obj = objs(o);
for l = 1:length(obj.label_patterns)
if strcmp(obj.label_patterns{l}, pattern)
display('Label already specified.');
return;
end
end
if isempty(obj.label_patterns)
obj.label_patterns{1} = pattern;
else
if iscell(obj.label_patterns);
for i = 1:length(obj.label_patterns)
obj.label_patterns{i} = obj.label_patterns{i};
end
obj.label_patterns{i+1} = pattern;
end
end
objs(o) = obj;
end

17
PDToolkit/@PDSession/setLabelRelativeToLabel.m Normal file
View File

@@ -0,0 +1,17 @@
function[obj] = setLabelRelativeToLabel(objs, target, name, time)
%% define possible coding styles of markers
if (~ischar(name))
error('Pattern must be character array')
end
%% lookup label_pattern:
label_ind = find(~cellfun(@isempty,regexp(obj.label_patterns, target)));
if isempty(item)
error(sprintf('Target label is unknown: %s', target));
end
e.subjects.sessions.label_dependencies{label_ind} = {name time};

17
PDToolkit/@PDSession/setLabelRelativeToPattern.m Normal file
View File

@@ -0,0 +1,17 @@
function[obj] = setLabelRelativeToPattern(objs, target, name, time)
%% define possible coding styles of markers
if (~ischar(name))
error('Pattern must be character array')
end
%% lookup label_pattern:
label_ind = find(~cellfun(@isempty,regexp(obj.label_patterns, target)));
if isempty(item)
error(sprintf('Target label is unknown: %s', target));
end
e.subjects.sessions.label_dependencies{label_ind} = {name time};

50
PDToolkit/@PDSession/setPattern.m Normal file
View File

@@ -0,0 +1,50 @@
function[objs] = setPattern(objs, type, pattern)
%% define possible coding styles of markers
ton_codings = {'trial onset','trial on', 'start trial', 'trial start', 'trial_start'};
toff_codings = {'trial offset','trial off', 'end trial', 'trial end', 'trial_end'};
son_codings = {'stimulus onset','stimulus on', 'soa', 'stim on', 'stim_on', 'stimulus start', 'stim_start'};
soff_codings = {'stimulus offset','stimulus off', 'stim off', 'stim_off', 'stim end', 'stim_end'};
bon_codings = {'baseline on', 'baseline start', 'baseline onset', 'bl on', 'bl'};
boff_codings = {'baseline off', 'baseline end', 'baseline offset', 'bl off'};
if (~ischar(pattern))
error('Pattern must be character array')
end
for i = 1:length(objs)
obj = objs(i);
%% trial onset
if (ismember(lower(type), ton_codings))
obj.trial_start_pattern = pattern;
end
if (ismember(lower(type), toff_codings))
obj.trial_end_pattern = pattern;
end
%% stimulus onset
if (ismember(lower(type), son_codings))
obj.stimulus_onset_pattern = pattern;
end
%% stimulus offset
if (ismember(lower(type), soff_codings))
obj.stimulus_offset_pattern = pattern;
end
%% baseline onset
if (ismember(lower(type), bon_codings))
obj.baseline_onset_pattern = pattern;
end
%% baseline offset
if (ismember(lower(type), boff_codings))
obj.baseline_offset_pattern = pattern;
end
objs(i) = obj;
end

47
PDToolkit/@PDSession/setPatternMulti.m Normal file
View File

@@ -0,0 +1,47 @@
function[obj] = setPatternMulti(obj, type, pattern)
%% define possible coding styles of markers
ton_codings = {'trial onset','trial on', 'start trial', 'trial start', 'trial_start'};
toff_codings = {'trial offset','trial off', 'end trial', 'trial end', 'trial_end'};
son_codings = {'stimulus onset','stimulus on', 'soa', 'stim on', 'stim_on'};
soff_codings = {'stimulus offset','stimulus off', 'stim off', 'stim_off'};
bon_codings = {'baseline on', 'baseline start', 'baseline onset', 'bl on', 'bl'};
boff_codings = {'baseline off', 'baseline end', 'baseline offset', 'bl off'};
if (ismember(lower(type), ton_codings))
ci = length(obj.trial_start_pattern) +1;
obj.trial_start_pattern(ci).pattern = pattern;
end
if (ismember(lower(type), toff_codings))
ci = length(obj.trial_end_pattern) +1;
obj.trial_end_pattern(ci).pattern = pattern;
end
%% stimulus onset
if (ismember(lower(type), son_codings))
ci = length(obj.stimulus_onset_pattern) +1;
obj.stimulus_onset_pattern(ci).pattern = pattern;
end
%% stimulus offset
if (ismember(lower(type), soff_codings))
ci = length(obj.stimulus_offset_pattern) +1;
obj.stimulus_offset_pattern(ci).pattern = pattern;
end
%% baseline onset
if (ismember(lower(type), bon_codings))
ci = length(obj.baseline_onset_pattern) +1;
obj.baseline_onset_pattern(ci).pattern = pattern;
end
%% baseline offset
if (ismember(lower(type), boff_codings))
ci = length(obj.baseline_offset_pattern) +1;
obj.baseline_offset_pattern(ci).pattern = pattern;
end

68
PDToolkit/@PDSession/setPatternRelativeToPattern.m Normal file
View File

@@ -0,0 +1,68 @@
function[objs] = setPatternRelativeToPattern(objs, relativeTotype,type, timing)
%% Specify a new marker/pattern relative in time to an existing pattern
% time should be milliseconds (ms).
if ~isnumeric(timing)
error('Timing is not numeric');
end
ton_codings = {'trial onset','trial on', 'start trial', 'trial start', 'trial_start'};
toff_codings = {'trial offset','trial off', 'end trial', 'trial end', 'trial_end'};
son_codings = {'stimulus onset','stimulus on', 'soa', 'stim on', 'stim_on'};
soff_codings = {'stimulus offset','stimulus off', 'stim off', 'stim_off'};
bon_codings = {'baseline on', 'baseline start', 'baseline onset', 'bl on', 'bl'};
boff_codings = {'baseline off', 'baseline end', 'baseline offset', 'bl off'};
ton = ismember(lower(relativeTotype), ton_codings);
toff = ismember(lower(relativeTotype), toff_codings);
son = ismember(lower(relativeTotype), son_codings);
soff = ismember(lower(relativeTotype), soff_codings);
bon = ismember(lower(relativeTotype), bon_codings);
boff = ismember(lower(relativeTotype), boff_codings);
types = [ton toff son soff bon boff];
type_ind = find(types==1);
for i = 1:length(objs)
obj = objs(i);
if isempty(type_ind)
error('No correct type entered');
else
err=0;
switch type_ind
case 1
if (isempty(obj.trial_start_pattern)), err=1; else target = 'trial_start'; end
case 2
if (isempty(obj.trial_end_pattern)), err=1; else target = 'trial_end'; end
case 3
if (isempty(obj.stimulus_onset_pattern)), err=1; else target = 'stimulus_onset'; end
case 4
if (isempty(obj.stimulus_offset_pattern)), err=1; else target = 'stimulus_offset'; end
case 5
if (isempty(obj.baseline_onset_pattern)), err=1; else target = 'baseline_onset'; end
case 6
if (isempty(obj.baseline_offset_pattern)), err=1; else target = 'baseline_offset'; end
end
end
if err
error('Dependent type has not been defined');
end
if (ismember(lower(type), ton_codings)) obj.trial_start_pattern = {timing target}; end
if (ismember(lower(type), toff_codings)) obj.trial_end_pattern = {timing target}; end
if (ismember(lower(type), son_codings)) obj.stimulus_onset_pattern = {timing target}; end
if (ismember(lower(type), soff_codings)) obj.stimulus_onset_pattern = {timing target}; end
if (ismember(lower(type), bon_codings)) obj.baseline_onset_pattern = {timing target}; end
if (ismember(lower(type), boff_codings)) obj.baseline_offset_pattern = {timing target}; end
objs(i) = obj;
end

7
PDToolkit/@PDSession/setSettings.m Normal file
View File

@@ -0,0 +1,7 @@
function[obj] = setSettings(obj, settings)
obj.settings = settings;
for t = 1:length(obj.trials)
obj.trials(t) = obj.trials(t).setSettings(settings);
end

4
PDToolkit/@PDSession/setTrialStart.m Normal file
View File

@@ -0,0 +1,4 @@
function[obj] = setTrialStart(obj, pattern);
obj.trials = [];

12
PDToolkit/@PDSession/smooth.m Normal file
View File

@@ -0,0 +1,12 @@
function[obj] = smooth(obj, settings)
%% Session based smoothing
eyes = fieldnames(obj.data);
for e = 1:length(eyes)
eye = eyes{e};
if ~isempty(obj.data.(eye).uncorrected.interpolated)
obj.data.(eye).uncorrected.filtered = conv(obj.data.(eye).uncorrected.interpolated, ones(1,settings.FilterSize), 'same') / settings.FilterSize;
end
end