update to use textures for aperture and dots

also includes
- some refactoring
- specifying dot density in number per visual angle square and total number
-  using new CPP_PTB sub-functions

Author: Remi-Gau

initEnv.m

@@ -86,7 +86,7 @@
 function addDependencies()
 
     pth = fileparts(mfilename('fullpath'));
-    addpath(fullfile(pth, 'lib', 'CPP_BIDS'));
+    addpath(fullfile(pth, 'lib', 'CPP_BIDS', 'src'));
     addpath(fullfile(pth, 'lib', 'CPP_PTB'));
     addpath(fullfile(pth, 'subfun'));
 

setParameters.m

@@ -40,7 +40,7 @@
     % Time between events in secs
     cfg.ISI = 0.1;
     % Number of seconds before the motion stimuli are presented
-    cfg.onsetDelay = 5;
+    cfg.onsetDelay = 1;
     % Number of seconds after the end all the stimuli before ending the run
     cfg.endDelay = 1;
 
@@ -51,20 +51,21 @@
     cfg.eventDuration = 1; % second
 
     % speed in visual angles
-    cfg.dot.speed = 8;
+    cfg.dot.speed = 1;
     % Coherence Level (0-1)
-    cfg.dot.coh = 1;
-    % Maximum number dots per frame
-    cfg.dot.maxNbPerFrame = 300;
+    cfg.dot.coh = .7;
+    % nb dots per visual angle square.
+    cfg.dot.density = 5; 
+    
     % Dot life time in seconds
     cfg.dot.lifeTime = 1;
     % Dot Size (dot width) in visual angles.
     cfg.dot.size = 0.1;
     cfg.dot.color = cfg.color.white;
-    cfg.dot.dontClear = 0;
 
     % Diameter/length of side of aperture in Visual angles
-    cfg.diameterAperture = 8;
+    cfg.aperture.type = 'circle';
+    cfg.aperture.width = []; % if left empty it will take the screen height
 
     %% Task(s)
 
@@ -74,14 +75,11 @@
     cfg.task.instruction = '1-Detect the RED fixation cross\n \n\n';
 
     % Fixation cross (in pixels)
-    % Set the length of the lines of the fixation cross
-    cfg.fixation.dimensionPix = 10;
-    % Set the line width for our fixation cross
-    cfg.fixation.lineWidthPix = 4;
-    cfg.fixation.xDisplacement = 0; % Manual displacement of the fixation cross
-    cfg.fixation.yDisplacement = 0; % Manual displacement of the fixation cross
-    cfg.fixation.color = cfg.color.white;
+    cfg.fixation.type = 'cross';
     cfg.fixation.colorTarget = cfg.color.red;
+    cfg.fixation.color = cfg.color.white;
+    cfg.fixation.width = .15;
+    cfg.fixation.lineWidthPix = 2;
 
     cfg.target.maxNbPerBlock = 2;
     cfg.target.duration = 0.15; % In secs

subfun/doDotMo.m

@@ -16,146 +16,143 @@
     % dots outside of the aperture is turned into a NaN so effectively the
     % actual number of dots on the screen at any given time is not the one that you input but a
     % smaller number (nDots / Area of aperture) on average.
-
+    
     %% Get parameters
-    dontClear  = cfg.dot.dontClear;
-
     direction = thisEvent.direction(1);
     isTarget = thisEvent.target(1);
-    speed = thisEvent.speed(1);
-
-    coh = cfg.dot.coh;
-    ndots = cfg.dot.maxNbPerFrame;
-    dotSizePix = cfg.dot.sizePix;
+    
+    
     dotLifeTime = cfg.dot.lifeTime;
-    dotColor = cfg.dot.color;
-
+    
     targetDuration = cfg.target.duration;
-
+    
     % thisEvent = deg2Pix('speed', thisEvent, cfg);
     % dotSpeedPix = logFile.iEventSpeedPix;
-
-    diamAperturePix = cfg.diameterAperturePix;
-    diamAperture = cfg.diameterAperture;
-
+    
+    coh = cfg.dot.coh;
+    speed = thisEvent.speed(1);
     % Check if it is a static or motion block
     if direction == -1
-
-        % dotSpeedPix = 0;
-
+        
         speed = 0;
-
+        coh = 1;
+        
         dotLifeTime = cfg.eventDuration;
     end
-
+    
     %% initialize variables
-
+    
     % Set an array of dot positions [xposition, yposition]
     % These can never be bigger than 1 or lower than 0
-    % [0,0] is the top / left of the square that contains the square aperture
-    % [1,1] is the bottom / right of the square that contains the square aperture
-    xy = rand(ndots, 2);
-
+    % [0,0] is the top / left of the square
+    % [1,1] is the bottom / right of the square
+    dotPositions = rand(cfg.dot.number, 2);
+    
     % Set a N x 2 matrix that gives jump size in pixels
     %  pix/sec * sec/frame = pix / frame
     dxdy = repmat( ...
-        speed * 10 / (diamAperture * 10) * (3 / cfg.screen.monitorRefresh) * ...
-        [cos(pi * direction / 180.0) -sin(pi * direction / 180.0)], ndots, 1);
-
+        speed * 10 / (cfg.aperture.width * 10) * (3 / cfg.screen.monitorRefresh) * ...
+        [cos(pi * direction / 180.0) -sin(pi * direction / 180.0)], cfg.dot.number, 1);
+    
     % dxdy = repmat(...
     %     dotSpeedPix / Cfg.ifi ...
     %     * (cos(pi*direction/180) - sin(pi*direction/180)), ...
     %     ndots, 1);
-
+    
     % Create a ones vector to update to dotlife time of each dot
-    dotTime = ones(size(xy, 1), 1);
-
-    % Set for how many frames to show the dots
-    continueShow = floor(cfg.eventDuration / cfg.screen.ifi);
-
+    dotTime = ones(size(dotPositions, 1), 1);
+    
     % Covert the dotLifeTime from seconds to frames
     dotLifeTime = ceil(dotLifeTime / cfg.screen.ifi);
+    
+    % Set for how many frames this event will last
+    framesLeft = floor(cfg.eventDuration / cfg.screen.ifi);
 
     %% Start the dots presentation
-    vbl = Screen('Flip', cfg.screen.win, 0, dontClear);
+    vbl = Screen('Flip', cfg.screen.win);
     onset = vbl;
-
-    while continueShow
-
+    
+    while framesLeft
+        
         % L are the dots that will be moved
-        L = rand(ndots, 1) < coh;
-
+        L = rand(cfg.dot.number, 1) < coh;
+        
         % Move the selected dots
-        xy(L, :) = xy(L, :) + dxdy(L, :);
-
+        dotPositions(L, :) = dotPositions(L, :) + dxdy(L, :);
+        
         % If not 100% coherence, we get new random locations for the other dots
         if sum(~L) > 0
-            xy(~L, :) = rand(sum(~L), 2);
+            dotPositions(~L, :) = rand(sum(~L), 2);
         end
-
+        
         % Create a logical vector to detect any dot that has:
         % - an xy position inferior to 0
         % - an xy position superior to 1
         % - has exceeded its liftime
-        N = any([xy > 1, xy < 0, dotTime > dotLifeTime], 2) ;
-
+        N = any([dotPositions > 1, dotPositions < 0, dotTime > dotLifeTime], 2) ;
+        
         % If there is any such dot we relocate it to a new random position
         % and change its lifetime to 1
         if any(N)
-            xy(N, :) = rand(sum(N), 2);
+            dotPositions(N, :) = rand(sum(N), 2);
             dotTime(N, 1) = 1;
         end
-
-        % Convert the dot position to pixels
-        xy_pix = floor(xy * diamAperturePix);
-
+        
+        %% Convert the dot position to pixels
+        % We expand that square so that its side is equal to the whole
+        % screen width.
+        % With no aperture the whole screen is filled with dots.
+        dotPositionsPix = floor(dotPositions * cfg.screen.winRect(3));
+        
         % This assumes that zero is at the top left, but we want it to be
         %  in the center, so shift the dots up and left, which just means
         %  adding half of the aperture size to both the x and y direction.
-        xy_pix = (xy_pix - diamAperturePix / 2)';
-
-        % NaN out-of-circle dots
-        % We use Pythagore's theorem to figure out which dots are out of the
-        % circle
-        outCircle = sqrt(xy_pix(1, :).^2 + xy_pix(2, :).^2) + ...
-            dotSizePix / 2 > (diamAperturePix / 2);
-        xy_pix(:, outCircle) = NaN;
-
-        %% PTB draws the dots stimulation
-
-        % Draw the fixation cross
-        color = cfg.fixation.color;
+        dotPositionsPix = (dotPositionsPix - cfg.screen.winRect(3) / 2)';
+        
+        thisEvent.dot.positions = dotPositionsPix;
+        
+        %% make textures
+        dotTexture('make', cfg, thisEvent);
+        
+        apertureTexture('make', cfg, thisEvent);
+        
+        %% draw evetything and flip screen
+        
+        dotTexture('draw', cfg, thisEvent);
+        
+        apertureTexture('draw', cfg, thisEvent);
+        
         % If this frame shows a target we change the color
+        thisFixation.fixation = cfg.fixation;
+        thisFixation.screen = cfg.screen;
         if GetSecs < (onset + targetDuration) && isTarget == 1
-            color = cfg.fixation.colorTarget;
+            thisFixation.fixation.color = cfg.fixation.colorTarget;
         end
-        drawFixationCross(cfg, color);
-
-        % Draw the dots
-        Screen('DrawDots', cfg.screen.win, xy_pix, dotSizePix, dotColor, cfg.screen.center, 2);
-
-        Screen('DrawingFinished', cfg.screen.win, dontClear);
-
-        vbl = Screen('Flip', cfg.screen.win, vbl + cfg.screen.ifi, dontClear);
-
+        drawFixation(thisFixation);
+        
+        Screen('DrawingFinished', cfg.screen.win);
+        
+        vbl = Screen('Flip', cfg.screen.win, vbl + cfg.screen.ifi);
+        
         %% Update counters
-
+        
         % Check for end of loop
-        continueShow = continueShow - 1;
-
+        framesLeft = framesLeft - 1;
+        
         % Add one frame to the dot lifetime to each dot
         dotTime = dotTime + 1;
-
+        
     end
-
+    
     %% Erase last dots
-
-    drawFixationCross(cfg, cfg.fixation.color);
-
-    Screen('DrawingFinished', cfg.screen.win, dontClear);
-
-    vbl = Screen('Flip', cfg.screen.win, vbl + cfg.screen.ifi, dontClear);
-
+    
+    drawFixation(cfg);
+    
+    Screen('DrawingFinished', cfg.screen.win);
+    
+    vbl = Screen('Flip', cfg.screen.win, vbl + cfg.screen.ifi);
+    
     duration = vbl - onset;
-
+    
 end
+

visualLocTanslational.m

@@ -25,16 +25,6 @@
 cfg = userInputs(cfg);
 cfg = createFilename(cfg);
 
-disp(cfg);
-
-% REFACTOR
-% Prepare for fixation Cross
-cfg.xCoords = [-cfg.fixation.dimensionPix cfg.fixation.dimensionPix 0 0] + ...
-    cfg.fixation.xDisplacement;
-cfg.yCoords = [0 0 -cfg.fixation.dimensionPix cfg.fixation.dimensionPix] + ...
-    cfg.fixation.yDisplacement;
-cfg.allCoords = [cfg.xCoords; cfg.yCoords];
-
 %%  Experiment
 
 % Safety loop: close the screen if code crashes
@@ -44,8 +34,11 @@
     [cfg] = initPTB(cfg);
 
     % Convert some values from degrees to pixels
-    cfg = degToPix('diameterAperture', cfg, cfg);
     cfg.dot = degToPix('size', cfg.dot, cfg);
+    
+    % dots are displayed on a square with a length in visual angle equal to the
+    % field of view
+    cfg.dot.number = cfg.dot.density * cfg.screen.FOV^2;
 
     [el] = eyeTracker('Calibration', cfg);
 
@@ -56,28 +49,24 @@
     % Prepare for the output logfiles with all
     logFile.extraColumns = cfg.extraColumns;
     logFile = saveEventsFile('open', cfg, logFile);
-
-    % Wait for space key to be pressed
-    pressSpaceForMe();
-
+    
+    % prepare textures
+    cfg = apertureTexture('init', cfg);
+    cfg = dotTexture('init', cfg);
+    
+    disp(cfg);
+    
+    standByScreen(cfg);
+    
     % prepare the KbQueue to collect responses
     getResponse('init', cfg.keyboard.responseBox, cfg);
     getResponse('start', cfg.keyboard.responseBox);
 
-    % Show instructions
-    DrawFormattedText(cfg.screen.win, cfg.task.instruction, ...
-        'center', 'center', cfg.text.color);
-    Screen('Flip', cfg.screen.win);
-
     % Wait for Trigger from Scanner
     waitForTrigger(cfg);
 
-    % Show the fixation cross
-    drawFixationCross(cfg, cfg.fixation.color);
-    Screen('Flip', cfg.screen.win);
-
     %% Experiment Start
-    cfg.experimentStart = GetSecs;
+    cfg = getExperimentStart(cfg);
 
     WaitSecs(cfg.onsetDelay);
 
@@ -152,14 +141,14 @@
     % End of the run for the BOLD to go down
     WaitSecs(cfg.endDelay);
 
+    cfg = getExperimentEnd(cfg);
+    
     % Close the logfiles
     saveEventsFile('close', cfg, logFile);
 
     getResponse('stop', cfg.keyboard.responseBox);
     getResponse('release', cfg.keyboard.responseBox);
 
-    totalExperimentTime = GetSecs - cfg.experimentStart;
-
     eyeTracker('Shutdown', cfg);
 
     % save the whole workspace
@@ -171,6 +160,8 @@
     else
         save(matFile, '-v7.3');
     end
+    
+    farewellScreen(cfg);
 
     cleanUp();