Merge pull request #60 from cpp-lln-lab/remi-localizer_update

localizer update: several things on the dot motion functions

Author: Remi-Gau

apertureTexture.m

@@ -40,6 +40,10 @@
                     Screen('FillOval', cfg.aperture.texture, transparent, ...
                         CenterRectOnPoint([0 0 repmat(diameter, 1, 2)], ...
                         xPos, yPos));
+                    
+                otherwise
+                    
+                    error('unknown aperture type: %s.', cfg.aperture.type);
 
             end
 

initializeDots.m

@@ -0,0 +1,7 @@
+function cartesianCoordinates = computeCartCoord(positions, cfg)
+    cartesianCoordinates = ...
+        [positions(:,1) + cfg.dot.matrixWidth, ... % x coordinate
+        positions(:,2) + cfg.dot.matrixWidth]; % y coordinate
+    
+%         cartesianCoordinates = positions;
+end

src/dot/computeCartCoord.m

@@ -0,0 +1,13 @@
+function angleMotion = computeRadialMotionDirection(cfg, dots)
+    
+    cartesianCoordinates = computeCartCoord(dots.positions, cfg);
+    
+    [angleMotion, ~] = cart2pol(cartesianCoordinates(:, 1), cartesianCoordinates(:, 2));
+    angleMotion = angleMotion / pi * 180;
+    
+    if dots.direction == -666
+        angleMotion = angleMotion - 180;
+    end
+    
+end
+

src/dot/computeRadialMotionDirection.m

@@ -1,4 +1,4 @@
-function [horVector, vertVector] = decompMotion(angleMotion)
+function [horVector, vertVector] = decomposeMotion(angleMotion)
     % decompose angle of start motion into horizontal and vertical vector
     horVector = cos(pi * angleMotion / 180);
     vertVector = -sin(pi * angleMotion / 180);

decompMotion.m renamed to src/dot/decomposeMotion.m

@@ -0,0 +1,5 @@
+function newPositions = generateNewDotPositions(cfg, dotNumber)
+    
+    newPositions = rand(dotNumber, 2) * cfg.dot.matrixWidth;
+    
+end

dotTexture.m renamed to src/dot/dotTexture.m

@@ -0,0 +1,68 @@
+function [dots] = initDots(cfg, thisEvent)
+    % [dots] = initDots(cfg, thisEvent)
+    %
+    % % Dot life time in seconds
+    % cfg.dot.lifeTime
+    % % Number of dots
+    % cfg.dot.number
+    % Proportion of coherent dots.
+    % cfg.dot.coherence
+    %
+    % % Direction (an angle in degrees)
+    % thisEvent.direction
+    % % Speed expressed in pixels per frame
+    % thisEvent.speed
+    %
+    %
+
+    % TODO
+    % bound direction between 0 and 360 ??
+
+    dots.direction = thisEvent.direction(1);
+
+    speedPixPerFrame = thisEvent.speed(1);
+
+    lifeTime = cfg.dot.lifeTime;
+
+    % 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 dots.direction == -1
+        speedPixPerFrame = 0;
+        lifeTime = Inf;
+        dots.isSignal = true(cfg.dot.number, 1);
+    end
+
+    %% 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 = generateNewDotPositions(cfg, cfg.dot.number);
+
+    %% Set vertical and horizontal speed for all dots
+    dots = setDotDirection(cfg, dots);
+
+    [horVector, vertVector] = decomposeMotion(dots.directionAllDots);
+    speeds = [horVector, vertVector];
+
+    % we were working with unit vectors. we now switch to pixels
+    speeds = speeds * speedPixPerFrame;
+
+    %% Create a vector to update to dotlife time of each dot
+    % Not all set to 1 so the dots will die at different times
+    % The maximum value is the duraion of the event in frames
+    time = floor(rand(cfg.dot.number, 1) * cfg.eventDuration / cfg.screen.ifi);
+
+    %% Convert from seconds to frames
+    lifeTime = ceil(lifeTime / cfg.screen.ifi);
+
+    %%
+    dots.lifeTime = lifeTime;
+    dots.time = time;
+    dots.speeds = speeds;
+    dots.speedPixPerFrame = speedPixPerFrame;
+
+end
+
+

src/dot/generateNewDotPositions.m

@@ -0,0 +1,43 @@
+function dots = reseedDots(dots, cfg)
+    
+    fixationWidthPix = 0;
+    if isfield(cfg.fixation, 'widthPix')
+        fixationWidthPix = cfg.fixation.widthPix;
+    end
+    
+    cartesianCoordinates = computeCartCoord(dots.positions, cfg);
+    [~, radius] = cart2pol(cartesianCoordinates(:, 1), cartesianCoordinates(:, 2));
+    
+
+    
+    % Create a logical vector to detect any dot that has:
+    % - an xy position inferior to 0
+    % - an xy position superior to winWidth
+    % - has exceeded its liftime
+    % - is on the fixation cross
+    % - has been been picked to be killed
+    
+    N = any([ ...
+        dots.positions > cfg.dot.matrixWidth, ...
+        dots.positions < 0, ...
+        dots.time > dots.lifeTime, ...
+        radius - cfg.dot.sizePix < fixationWidthPix / 2, ...
+        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, :) = generateNewDotPositions(cfg, sum(N));
+        
+        dots = setDotDirection(cfg, dots);
+        
+        [horVector, vertVector] = decomposeMotion(dots.directionAllDots);
+        dots.speeds = [horVector, vertVector] * dots.speedPixPerFrame;
+        
+        dots.time(N, 1) = 1;
+        
+    end
+    
+end

src/dot/initDots.m

@@ -0,0 +1,19 @@
+function dots = setDotDirection(cfg, dots)
+
+    directionAllDots = nan(cfg.dot.number, 1);
+
+    % Coherent dots
+    directionAllDots(dots.isSignal) = dots.direction;
+    
+    if strcmp(cfg.design.motionType, 'radial')
+        angleMotion = computeRadialMotionDirection(cfg, dots);
+        directionAllDots(dots.isSignal) = angleMotion;
+    end
+
+    % Random direction for the non coherent dots
+    directionAllDots(~dots.isSignal) = rand(sum(~dots.isSignal), 1) * 360;
+    directionAllDots = rem(directionAllDots, 360);
+    
+    dots.directionAllDots = directionAllDots;
+
+end