3D Stimulus Presentation with the VIEWPixx /3D

function helloWorldVPx3D()
%A simple demonstration of Stereo Blue Lines. 
%Draws "hello" and "world" to the left and right eyes.
%Helper functions initialize the VIEWPixx /3D and draw the blue lines on
%the correct frame.

% Initialize
initializeVIEWPixx3D();

% Initialize Psychtoolbox window
screenNumber = max(Screen('Screens'));
[windowPtr, rect] = PsychImaging('OpenWindow', screenNumber, 0);

% Initialize stimuli
helloText = 'Hello';
worldText = 'World';

% Start loop drawing the message
while true
    DrawFormattedText(windowPtr, helloText, 'center', 'center', 255);
    drawBlueLine(windowPtr, rect, 1);
    Screen('Flip', windowPtr);

    DrawFormattedText(windowPtr, worldText, 'center', 'center', 255);
    drawBlueLine(windowPtr, rect, 0);
    Screen('Flip', windowPtr);
    
    %Check for escape
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

% Shut down
sca;
Datapixx('Close');
end

%%% Some helper functions 

function initializeVIEWPixx3D()
% All VPixx hardware commands to set the right mode 
Datapixx('Open');
Datapixx('SetVideoMode', 0); %C24
Datapixx('EnableVideoStereoBlueline');
Datapixx('SetVideoStereoVesaWaveform', 2); %NVIDIA
Datapixx('SetVideoStereoVesaPhase', 100);
Datapixx('RegWr');

%For older models of VIEWPixx /3D, uncomment the following
%Datapixx('EnableVideoLcd3D60Hz');
%Datapixx('RegWr');
end

function drawBlueLine(windowPtr, rect, frame)
% Helper function to draw lines on the appropriate image
% if Frame = 0 draw right eye blueline
% if Frame = 1, draw left eye no blueline
% Call immediately before flip
if frame == 0
    frameColor = [255, 255, 255];
else
    frameColor = [0, 0, 0];
end
rowStart = [rect(1), rect(4)-1];
rowEnd = [rect(3), rect(4)-1];
Screen('DrawLine', windowPtr, frameColor, rowStart(1), rowStart(2), rowEnd(1), rowEnd(2),2);
end

#A simple demonstration of Stereo Blue Lines. 
#Draws "hello" and "world" to the left and right eyes.
#Helper functions initialize the VIEWPixx /3D and draw the blue lines on
#the correct frame.

from psychopy import core, visual
from psychopy.hardware import keyboard
from pypixxlib.viewpixx import VIEWPixx3D
from pypixxlib._libdpx import DPxEnableVidLcd3D60Hz, DPxSetVidVesaPhase


def initializeVPx3D():
    #All VPixx hardware commands to set the right mode for the VIEWPixx 3D
    my_device = VIEWPixx3D()
    my_device.setVideoMode('C24')
    my_device.setVideoVesaBlueline(True)
    my_device.setVesaWaveform('NVIDIA')
    DPxSetVidVesaPhase(100)
    my_device.writeRegisterCache()
    
    #For older models of VIEWPixx /3D, uncomment the following
    #DPxEnableVidLcd3D60Hz()
    #my_device.writeRegisterCache()    
    return my_device
    

def drawBlueLine(win, frame=0):
    #if Frame = 0, draw right eye blueline
    #if Frame = 1 draw left eye no blueline
    #Call immediately before flip
    if frame==0: 
        frameColor = [255,255,255]
    else:
        frameColor = [0,0,0]
            
    rowStart= [-win.size[0]/2, -win.size[1]/2]
    rowEnd =[win.size[0]/2, -win.size[1]/2]
        
    line = visual.Line(
            win=win,
            units = 'pix',
            start=rowStart,
            end=rowEnd,
            interpolate = False,
            colorSpace = 'rgb255',
            lineColor = frameColor)
    line.draw()
    
    
#Begin Experiment
kb = keyboard.Keyboard()
VPx = initializeVPx3D()
win = visual.Window(
        screen = 1,
        monitor =None, 
        fullscr=True,
        color='black',
        units = "pix"
        )

hello = visual.TextStim(win=win, text='Hello')
world = visual.TextStim(win=win, text='World')

while True:

    hello.draw()
    drawBlueLine(win, frame=1)
    win.flip()

    world.draw()
    drawBlueLine(win, frame=0)
    win.flip()

    keys = kb.getKeys(keyList=['escape'])
    if keys:
        break
    
win.close()
core.quit()

function VPx3D_TopBottom()
%This demo draws a red and green square in the left and right eye views,
%respectively. Helper functions initialize and draw the blanking interval. 

% Initialize
initializeVIEWPixx3D();

% Initialize Psychtoolbox window
screenNumber = max(Screen('Screens'));
[windowPtr, ~] = PsychImaging('OpenWindow', screenNumber, 0);

% Initialize stimuli - arbitrarily picked a 120 pixel square in center of
% display. Left eye sees red (top image) and right eye sees green (bottom
% image)
leftEyeCenter = [1920/2,1080/2];
leftEyeBox = [leftEyeCenter(1)-60, leftEyeCenter(2)-60,leftEyeCenter(1)+60, leftEyeCenter(2)+60];
leftEyeCol = [255, 0, 0];

% Right eye is shifted down by 1080 plus blanking interval
rightEyeCenter = [1920/2,(1080+162)+1080/2];
rightEyeBox = [rightEyeCenter(1)-60, rightEyeCenter(2)-60, rightEyeCenter(1)+60, rightEyeCenter(2)+60];
rightEyeCol = [0, 255, 0];

% Start presentation loop 
while true
    Screen('FillRect', windowPtr, leftEyeCol, leftEyeBox);
    Screen('FillRect', windowPtr, rightEyeCol, rightEyeBox);
    drawBlankingInterval(windowPtr);
    Screen('Flip', windowPtr);
    
    %Check for escape
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

% Close the Psychtoolbox window
sca;
Datapixx('Close');
end

%%% Some helper functions 

function initializeVIEWPixx3D()
% All VPixx hardware commands to set the right mode 
Datapixx('Open');
Datapixx('SetVideoMode', 0); %C24
Datapixx('EnableVideoStereoBlueline');
Datapixx('SetVideoStereoVesaWaveform', 2); %NVIDIA
Datapixx('SetVideoStereoVesaPhase', 100);
Datapixx('RegWr');

%For older models of VIEWPixx /3D, uncomment the following
%Datapixx('EnableVideoLcd3D60Hz');
%Datapixx('RegWr');
end

function drawBlankingInterval(windowPtr)
% Helper function ensures blanking interval between top and bottom images 
% is in fact blank on each frame
rectCoords = [0, 1080, 1920, 1242];
rectColor = [0 0 0];
Screen('FillRect', windowPtr, rectColor, rectCoords);
end

#This demo draws a red and green square in the left and right eye views,
#respectively. Helper functions initialize and draw the blanking interval. 

from psychopy import core, visual
from psychopy.hardware import keyboard
from pypixxlib.viewpixx import VIEWPixx3D
from pypixxlib._libdpx import DPxEnableVidLcd3D60Hz, DPxSetVidVesaPhase

def initializeVPx3D():
    #All VPixx hardware commands to set the right mode for the VIEWPixx 3D
    my_device = VIEWPixx3D()
    my_device.setVideoMode('C24')
    my_device.setVideoVesaBlueline(True)
    my_device.setVesaWaveform('NVIDIA')
    DPxSetVidVesaPhase(100)
    my_device.writeRegisterCache()
    
    #For older models of VIEWPixx /3D, uncomment the following
    #DPxEnableVidLcd3D60Hz()
    #my_device.writeRegisterCache()    
    return my_device

def drawBlankingInterval(win):
    # Helper function to ensure blanking interval between top and bottom images is blank
    rect_coords = [0, 1080, 1920, 1242]
    blank_rect = visual.Rect(
        win=win,
        width=rect_coords[2],
        height=rect_coords[3] - rect_coords[1],
        pos=[rect_coords[2] / 2, (rect_coords[1] + rect_coords[3]) / 2],
        fillColor='black',
        lineColor='black'
    )
    blank_rect.draw()

   
#Begin Experiment
#Note that we set the origin to top left corner (in PsychoPy, down/left is negative). 
#This is helpful for drawing in pixel space. If you prefer to use normalized units, modify the
#viewPos argument below.
kb = keyboard.Keyboard()
VPx = initializeVPx3D()
win = visual.Window(
        screen = 1,
        viewPos=[-960, 2322/2],
        monitor =None, 
        fullscr=True,
        color='black',
        units = "pix"
        )

# Initialize stimuli - arbitrarily picked a 120 pixel square in center of display
left_eye_center = [1920 / 2, -1080 / 2]
# Center of right eye image is shifted down by 1080 plus blanking interval
right_eye_center = [1920 / 2, -1080 - 162 - 1080 / 2]

# Create squares for both eyes
left_eye_square = visual.Rect(
    win=win,
    width=120, height=120,
    pos=left_eye_center,
    fillColor='red',
    lineColor='red'
)

right_eye_square = visual.Rect(
    win=win,
    width=120, height=120,
    pos=right_eye_center,
    fillColor='green',
    lineColor='green'
)

# Main loop to draw the squares
while True:
    left_eye_square.draw()
    right_eye_square.draw()
    drawBlankingInterval(win)
    win.flip()
    
    # Check for escape key press
    keys = kb.getKeys()
    if 'escape' in keys:
        break

# Close the PsychoPy window
win.close()
core.quit()

%To enable mirrored greyscale mode
Datapixx('Open');
Datapixx('SelectDevice', 2, ‘LEFT’); % The 2 is for VIEWPixx
Datapixx('SetVideoGreyscaleMode', 1); %Red channel drives output
Datapixx('SelectDevice', 2, 'RIGHT');
Datapixx('SetVideoGreyscaleMode', 2); %Green channel drives the output
Datapixx('SelectDevice', -1); % Return to automatic device selection
Datapixx('RegWr');

%Experiment goes here. Draw all stimuli on the same display, with red channel
%for the left eye and green for the right eye.
 
% Then to turn this mode off
Datapixx('SelectDevice', 2, 'LEFT');
Datapixx('SetVideoGreyscaleMode', 0);
Datapixx('SelectDevice', 2, 'RIGHT');
Datapixx('SetVideoGreyscaleMode', 0);
Datapixx('SelectDevice', -1);
Datapixx('RegWr');
Datapixx('Close');

%This simple script draws a greyscale rectangle in both eyes, and some text
%on the console display (transparent on main display)

%Set up
%Establish the correct colour and video settings
AssertOpenGL;
PsychImaging('PrepareConfiguration');
PsychImaging('AddTask', 'General', 'FloatingPoint32Bit');
PsychImaging('AddTask', 'General', 'EnableDataPixxM16OutputWithOverlay');
KbName('UnifyKeyNames');

%Open a full-screen window with a black background
screenNumber = max(Screen('Screens'));
[win, winRect] = PsychImaging('OpenWindow', screenNumber, [0,0,0]);

%Make sure to disable anti-aliasing if you are using the colour overlay, as
%this can produce strange results.
Screen('Preference', 'TextAntiAliasing', 0); 

%Get our overlay window for our CLUTs
overlay = PsychImaging('GetOverlayWindow', win);

%Generate our colour look-up table (CLUT) for our main display.
%CLUT values are 0-1; the output is 16 bit (0-65535). 

%!! ON WINDOWS!!
% PTB scales colour by 255/256, therefore CLUT counting starts at the second row.
% See example below.

%!! ON OS-X !!
%CLUT assignment seems to have issues with mapping onto CLUTs. Consider making multiple (~5) rows 
%The same colour and calling the middle row to ensure a buffer. 

%The clut is first populated with black and then the first two rows are changed to blue and red
myTable=repmat([0,0,0], [256,1]);
myTable(2,:) = [0,0,1]; %Row 1
myTable(3,:)= [1,0,0];  %Row 2
myTable(4,:)= [1,1,1];  %Row 3 ... etc

%Create a copy of the first CLUT for the console and set row 1 to full blue 
myConsoleTable = myTable;
myConsoleTable(2,:) = [1,1,1]; %Row 1 of console CLUT

%Pass the CLUTS to the hardware
Datapixx('Open');
Datapixx('SetVideoClut', [myTable; myConsoleTable]);

%Let's set blue to be the transparency
myTransparency = [0,0,1];
Datapixx('SetVideoClutTransparencyColor', myTransparency);
Datapixx('EnableVideoClutTransparencyColorMode');

%Pass all commands to the hardware
Datapixx('RegWr');

%Determine our target gray value as a proportion of the maximum possible
%value. Remember this is 16-bit grayscale. 
midGrayLevel = 0.5;

% Start loop drawing our stimuli
while true
    
    %Draw a rectangle in the top left corner of the window and flip. This will
    %appear on both displays.
    Screen('FillRect', win, midGrayLevel, [0, 0, 400, 400]);
    
    %Text will be white on console, transparent on main display
    DrawFormattedText(overlay, 'Hello', 'center', 'center', 1);
    Screen('Flip', win);
    
    %Check for escape
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

% Shut down
sca;
Datapixx('DisableVideoClutTransparencyColorMode');
Datapixx('RegWr');
Datapixx('Close');