update dot algo

Author: Remi-Gau

setParameters.m

@@ -50,17 +50,21 @@
     cfg.numEventsPerBlock = 12;
     cfg.eventDuration = 1; % second
 
-    % speed in visual angles
-    cfg.dot.speed = 1;
+    % speed in visual angles / second
+    cfg.dot.speed = 15;
     % Coherence Level (0-1)
-    cfg.dot.coh = .7;
+    cfg.dot.coherence = 1;
     % nb dots per visual angle square.
-    cfg.dot.density = 5; 
+    cfg.dot.density = .25; 
 
     % Dot life time in seconds
-    cfg.dot.lifeTime = 1;
+    cfg.dot.lifeTime = 10;
+
+    % proportion of dots killed per frame
+    cfg.dot.proportionKilledPerFrame = .05;
+
     % Dot Size (dot width) in visual angles.
-    cfg.dot.size = 0.1;
+    cfg.dot.size = 1;
     cfg.dot.color = cfg.color.white;
 
     % Diameter/length of side of aperture in Visual angles

subfun/doDotMo.m

@@ -6,110 +6,34 @@
     %
     % Input:
     %   - cfg: PTB/machine configurations returned by setParameters and initPTB
-    %   - expParameters: parameters returned by setParameters
-    %   - logFile: structure that stores the experiment logfile to be saved
     %
     % Output:
     %     -
     %
-    % The dots are drawn on a square that contains the round aperture, then any
-    % 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.
+    % The dots are drawn on a square with a width equals to the width of the
+    % screen
+    % We then draw an aperture on top to hide the certain dots.
 
     %% Get parameters
-    direction = thisEvent.direction(1);
-    isTarget = thisEvent.target(1);
 
-    
-    dotLifeTime = cfg.dot.lifeTime;
-    
-    targetDuration = cfg.target.duration;
-    
-    % thisEvent = deg2Pix('speed', thisEvent, cfg);
-    % dotSpeedPix = logFile.iEventSpeedPix;
-    
-    coh = cfg.dot.coh;
-    speed = thisEvent.speed(1);
-    % Check if it is a static or motion block
-    if direction == -1
-        
-        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
-    % [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 / (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(dotPositions, 1), 1);
-    
-    % Covert the dotLifeTime from seconds to frames
-    dotLifeTime = ceil(dotLifeTime / cfg.screen.ifi);
+    dots = initializeDots(cfg, thisEvent);
 
     % 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);
     onset = vbl;
 
     while framesLeft
 
-        % L are the dots that will be moved
-        L = rand(cfg.dot.number, 1) < coh;
-        
-        % Move the selected dots
-        dotPositions(L, :) = dotPositions(L, :) + dxdy(L, :);
-        
-        % If not 100% coherence, we get new random locations for the other dots
-        if sum(~L) > 0
-            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([dotPositions > 1, dotPositions < 0, dotTime > dotLifeTime], 2) ;
+        [dots] = updateDots(dots, cfg);
 
-        % If there is any such dot we relocate it to a new random position
-        % and change its lifetime to 1
-        if any(N)
-            dotPositions(N, :) = rand(sum(N), 2);
-            dotTime(N, 1) = 1;
-        end
-        
-        %% 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
+        %% Center the dots
+        % We assumed 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.
-        dotPositionsPix = (dotPositionsPix - cfg.screen.winRect(3) / 2)';
-        
-        thisEvent.dot.positions = dotPositionsPix;
+        %  adding half of the screen width in pixel to both the x and y direction.
+        thisEvent.dot.positions = (dots.positions - cfg.screen.winWidth / 2)';
 
         %% make textures
         dotTexture('make', cfg, thisEvent);
@@ -125,7 +49,7 @@
         % If this frame shows a target we change the color
         thisFixation.fixation = cfg.fixation;
         thisFixation.screen = cfg.screen;
-        if GetSecs < (onset + targetDuration) && isTarget == 1
+        if thisEvent.target(1) && GetSecs < (onset + cfg.target.duration)
             thisFixation.fixation.color = cfg.fixation.colorTarget;
         end
         drawFixation(thisFixation);
@@ -139,9 +63,6 @@
         % Check for end of loop
         framesLeft = framesLeft - 1;
 
-        % Add one frame to the dot lifetime to each dot
-        dotTime = dotTime + 1;
-        
     end
 
     %% Erase last dots
@@ -155,4 +76,3 @@
     duration = vbl - onset;
 
 end
-

subfun/expDesign.m

@@ -38,7 +38,8 @@
 
     % Set directions for static and motion condition
     motionDirections = [0 90 180 270];
-    staticDirections = [-1 -1 -1 -1];
+    staticDirections = [0 90 180 270];
+%     staticDirections = [-1 -1 -1 -1];
 
     %% Check inputs
 
@@ -59,7 +60,7 @@
     % Get the parameters
     names = cfg.names;
     numRepetitions = cfg.numRepetitions;
-    speedEvent = cfg.dot.speed;
+    dotsSpeed = cfg.dot.speedPixPerFrame;
     numEventsPerBlock = cfg.numEventsPerBlock;
     maxNumFixTargPerBlock = cfg.target.maxNbPerBlock;
 
@@ -93,7 +94,7 @@
 
     cfg.design.blockNames      = cell(nrBlocks, 1);
     cfg.design.directions      = zeros(nrBlocks, numEventsPerBlock);
-    cfg.design.speeds          = ones(nrBlocks, numEventsPerBlock) * speedEvent;
+    cfg.design.speeds          = ones(nrBlocks, numEventsPerBlock) * dotsSpeed;
     cfg.design.fixationTargets = zeros(nrBlocks, numEventsPerBlock);
 
     for iMotionBlock = 1:numRepetitions

subfun/initializeDots.m

@@ -0,0 +1,50 @@
+function [dots] = initializeDots(cfg, thisEvent)
+    
+    direction = thisEvent.direction(1);
+    
+    dots.lifeTime = cfg.dot.lifeTime;
+    
+    speedPixPerFrame = thisEvent.speed(1); 
+    
+    % decide which dots are signal dots (1) and those are noise dots (0)
+    dots.isSignal = rand(cfg.dot.number, 1) < cfg.dot.coherence;
+    
+    % for static dots
+    if direction == -1
+        speedPixPerFrame = 0;
+        dots.lifeTime = cfg.eventDuration;
+        dots.isSignal = ones(cfg.dot.number, 1);
+    end
+    
+    % Convert from seconds to frames
+    dots.lifeTime = ceil(dots.lifeTime / cfg.screen.ifi);
+
+    % 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
+    % [1,1] is the bottom / right of the square
+    dots.positions = rand(cfg.dot.number, 2) * cfg.screen.winWidth;
+    
+    % Set a N x 2 matrix that speed in X and Y 
+    dots.speeds = nan(cfg.dot.number, 2);
+    
+    % Coherent dots
+    [horVector, vertVector] = decompMotion(direction);
+    dots.speeds(dots.isSignal,:) = ...
+        repmat([horVector, vertVector], sum(dots.isSignal), 1);
+    
+    % If not 100% coherence, we get new random direction for the other dots
+    direction = rand(sum(~dots.isSignal), 1) * 360;
+    [horVector, vertVector] = decompMotion(direction);
+    dots.speeds(~dots.isSignal, :) = [horVector, vertVector];
+    
+    % So far we were working wiht unit vectors convert that speed in pixels per
+    % frame
+    dots.speeds = dots.speeds * speedPixPerFrame;
+    
+    % Create a vector to update to dotlife time of each dot
+    % Not all set to one so the dots will die at different times
+    dots.time = floor(rand(cfg.dot.number, 1) * cfg.eventDuration / cfg.screen.ifi);
+    
+end
+

subfun/updateDots.m

@@ -0,0 +1,26 @@
+function [dots] = updateDots(dots, cfg)
+    
+    % Move the selected dots
+    dots.positions = dots.positions + dots.speeds;
+
+    % Create a logical vector to detect any dot that has:
+    % - an xy position inferior to 0
+    % - an x position superior to winWidth
+    % - an x position superior to winHeight
+    % - has exceeded its liftime
+    N = any([...
+        dots.positions > cfg.screen.winWidth, ...
+        dots.positions < 0, ...
+        dots.time > dots.lifeTime, ...
+        rand(cfg.dot.number,1) < cfg.dot.proportionKilledPerFrame ], 2) ;
+    
+    % If there is any such dot we relocate it to a new random position
+    % and change its lifetime to 1
+    if any(N)
+        dots.positions(N, :) = rand(sum(N), 2) * cfg.screen.winWidth;
+        dots.time(N, 1) = 1;
+    end
+    
+    % Add one frame to the dot lifetime to each dot
+    dots.time = dots.time + 1;
+end

visualLocTanslational.m

@@ -35,10 +35,16 @@
 
     % Convert some values from degrees to pixels
     cfg.dot = degToPix('size', cfg.dot, cfg);
+    cfg.dot = degToPix('speed', cfg.dot, cfg);
+    
+    % Get dot speeds in pixels per frame
+    cfg.dot.speedPixPerFrame = cfg.dot.speedPix / cfg.screen.monitorRefresh;
+    
+    cfg.aperture = degToPix('xPos', cfg.aperture, 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;
+    cfg.dot.number = round(cfg.dot.density * (cfg.screen.winWidth / cfg.screen.ppd)^2);
 
     [el] = eyeTracker('Calibration', cfg);