3D Projection with the PROPixx and 3D Polarizer

function helloWorld3D()

% Initialize PROPixx
initializePROPixx();

% Initialize Psychtoolbox window
PsychDefaultSetup(2);
screenNumber = max(Screen('Screens'));
[windowPtr, rect] = PsychImaging('OpenWindow', screenNumber, 0);
Screen('BlendFunction', windowPtr, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
HideCursor;

% 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);
    
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

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

function initializePROPixx()
% All VPixx hardware commands to set the right mode for the PROPixx
Datapixx('Open');
Datapixx('EnableVideoStereoBlueline');
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

from psychopy import core, visual
from psychopy.hardware import keyboard
from pypixxlib._libdpx import DPxOpen, DPxClose, DPxWriteRegCache, DPxEnableVidVesaBlueline, DPxSetVidMode

def initializePROPixx():
    #All VPixx hardware commands to set the right mode for the PROPixx
    DPxOpen()
    DPxSetVidMode('C24')
    DPxEnableVidVesaBlueline()
    DPxWriteRegCache()
    
def drawBlueLine(win, frame=0):
    #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]
    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, #MUST be set to false
            colorSpace = 'rgb255',
            lineColor = frameColor,
            lineWidth=2)
    line.draw()
    
#Begin Experiment
kb = keyboard.Keyboard()
initializePROPixx()
win = visual.Window(
        screen = 1,
        monitor =None, 
        fullscr=True,
        color='black',
        units = "pix"
        )

#Initialize our stimuli
hello = visual.TextStim(win=win, text='Hello')
world = visual.TextStim(win=win, text='World')

#Start a loop drawing our message
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()
DPxClose()

function helloWorld3DQuad4x()

% Initialize PROPixx
initializePROPixx();

% Initialize Psychtoolbox window
PsychDefaultSetup(2);
screenNumber = max(Screen('Screens'));
[windowPtr] = PsychImaging('OpenWindow', screenNumber, 0);
Screen('BlendFunction', windowPtr, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
HideCursor;

%Initialize quadrants for QUAD4x
quadrants = initializeQuadrants();

% Start drawing loop
while 1
    for quadrantID = fieldnames(quadrants)'
        quadrantID = quadrantID{1};

        % Create text stimulus according to quadrant
        if strcmp(quadrantID, 'Q1') || strcmp(quadrantID, 'Q3')
            text = 'Hello';
        else
            text = 'World';
        end
        
        oldPos = [1920/2, 1080/2]; %center of full screen display
        newPos = assignToQuadrant(oldPos, quadrants.(quadrantID));

        % Draw text & blueline
        Screen('DrawText', windowPtr, text, newPos(1), newPos(2),[255, 255, 255]);
    end
    
    % Flip screen after all four quadrants drawn
    Screen('Flip', windowPtr);

    %Check for escape
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end

end

% Close window and cleanup
sca;
closePROPixx();
end

%---- HELPER FUNCTIONS
function quadrants = initializeQuadrants()
  % Define quadrant parameters
  quadrants = struct(...
      'Q1', [0, 0], ...       % Top left
      'Q2', [960, 0], ...   % Top right
      'Q3', [0, 540], ...       % Bottom left
      'Q4', [960, 540] );    % Bottom right
end

function newpos = assignToQuadrant(oldpos, quadrantOffset)
    %Helper function to adjust position to quadrant. 
    newpos = [oldpos(1)/2+quadrantOffset(1), oldpos(2)/2+quadrantOffset(2)];
end

function initializePROPixx()
  % All VPixx hardware commands to set the right mode for the PROPixx
  Datapixx('Open');
  Datapixx('SetPropixxDlpSequenceProgram', 2); 
  Datapixx('RegWr');
  Datapixx('EnablePropixxQuad4x3d');
  Datapixx('RegWr');
end

function closePROPixx()
  % Return to defaults and shut down
  Datapixx('SetPropixxDlpSequenceProgram', 0); 
  Datapixx('DisablePropixxQuad4x3d');
  Datapixx('RegWr');
  Datapixx('Close')
end

from psychopy import visual
from psychopy.hardware import keyboard
from pypixxlib import _libdpx as dp

def hello_world_3d_quad4x():
    screenNumber = 1
    # Initialize PROPixx, keyboard  and window
    initialize_propixx()
    kb = keyboard.Keyboard()     
    win = visual.Window(fullscr=True, color=(-1, -1, -1),screen=screenNumber, units='pix')
    win.mouseVisible = False

    # Define quadrant offsets based on Cartesian coordinates
    width, height = win.size
    quadrants = {
        'Q1': [-width / 4, height / 4],    # Top left
        'Q2': [width / 4, height / 4],     # Top right
        'Q3': [-width / 4, -height / 4],   # Bottom left
        'Q4': [width / 4, -height / 4]     # Bottom right
    }

    # Main loop for drawing text in each quadrant
    while True:
        for quadrant_id, offset in quadrants.items():
            text = 'Hello' if quadrant_id in ['Q1', 'Q3'] else 'World'
            text_stim = visual.TextStim(win, text=text, pos=offset, color=(1, 1, 1))
            text_stim.draw()

        # Flip to update the screen and check for escape key
        win.flip()
        
        # Check for exit key
        keys = kb.getKeys()
        if 'escape' in keys:
            break
        
def initialize_propixx():
    # Initialize Propixx hardware
    dp.DPxOpen()    
    dp.DPxSetPPxDlpSeqPgrm('QUAD4X')
    dp.DPxPPxEnableQuad4x3D()
    dp.DPxWriteRegCache()

def close_propixx():
    # Close Propixx hardware and reset
    dp.DPxPPxDisableQuad4x3D()
    dp.DPxSetPPxDlpSeqPgrm('RGB 120Hz')
    dp.DPxWriteRegCache()
    dp.DPxClose()


# Run the function
hello_world_3d_quad4x()

function PROPixx_TopBottom()
%This demo draws a red and green square in the left and right eye views,
%respectively. 

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

% 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+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);
    Screen('Flip', windowPtr);
    
    %Check for escape
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

% Close the Psychtoolbox window
sca;
end

#This demo draws a red and green square in the left and right eye views,
#respectively. 

from psychopy import core, visual
from psychopy.hardware import keyboard
    
#Begin Experiment
kb = keyboard.Keyboard()
win = visual.Window(
        screen = 1,
        monitor =None, 
        fullscr=True,
        color='black',
        )

# Initialize stimuli in top and bottom halves of display
# Remember in PsychoPy, down/left is negative 

#Center of left eye image
left_eye_center = [0, 0.5]

# Center of right eye image
right_eye_center = [0, -0.5]

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

right_eye_square = visual.Rect(
    win=win,
    size=0.25,
    pos=right_eye_center,
    fillColor='green',
    lineColor='green'
)

# Main loop to draw the squares
while True:
    left_eye_square.draw()
    right_eye_square.draw()
    win.flip()

    # Check for escape key press
    keys = kb.getKeys()
    if 'escape' in keys:
        break

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

function helloWorldRB3D()

% Initialize PROPixx
initializePROPixx();

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

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

% You can modify the per eye crosstalk values here.
% Proportion left eye 'leak' into right eye 
Datapixx('SetPropixx3DCrosstalkLR', 0);
% Proportion right eye 'leak' into left eye 
Datapixx('SetPropixx3DCrosstalkRL', 0);
Datapixx('RegWr');

% Start loop drawing the message
while true

    %Select red channel while locking others (prevents overwriting colours)
    Screen('BlendFunction', windowPtr, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, [1 0 0 0]);
    DrawFormattedText(windowPtr, helloText, 'center', 'center', [255,0,0]);

    %Select blue channel while locking others (prevents overwriting colours)
    Screen('BlendFunction', windowPtr, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, [0 0 1 0]);
    DrawFormattedText(windowPtr, worldText, 'center', 'center', [0,0,255]);
    Screen('Flip', windowPtr);
    
    [~, ~, keyCode] = KbCheck;
    if keyCode(KbName('Escape'))
        break;
    end
end

% Close the Psychtoolbox window
sca;
closePROPixx();
end

function initializePROPixx()
  % All VPixx hardware commands to set the right mode for the PROPixx
  Datapixx('Open');
  Datapixx('SetPropixxDlpSequenceProgram', 1); 
  Datapixx('RegWr');
end

function closePROPixx()
  % Return to defaults and shut down
  Datapixx('SetPropixxDlpSequenceProgram', 0); 
  Datapixx('RegWr');
  Datapixx('Close');
end

from psychopy import visual
from psychopy.hardware import keyboard
from pypixxlib import _libdpx as dp

def hello_world_rb3d():

    screenNumber = 1
    # Initialize PROPixx
    initialize_propixx()
    
    # Initialize keyboard
    kb = keyboard.Keyboard()  

    # Set up PsychoPy window
    win = visual.Window(fullscr=True, color=(-1, -1, -1), screen=screenNumber, units='pix')
    
    # Define crosstalk
    set_crosstalk_right_eye(0)
    set_crosstalk_left_eye(0) 
    
    # Define the stimuli text
    hello_text = visual.TextStim(win, text='Hello', color=(1, -1, -1),height = 60)  # Red
    world_text = visual.TextStim(win, text='World', color=(-1, -1, 1),height = 60)  # Blue

    # Main loop to draw the text
    while True:
        # Draw "Hello" in red
        hello_text.draw()
        
        # Draw "World" in blue
        world_text.draw()

        # Flip window to show both texts
        win.flip()
        
        # Check for exit key
        keys = kb.getKeys()
        if 'escape' in keys:
            break

    # Close the PsychoPy window
    win.close()
    close_propixx()

def set_crosstalk_right_eye(crosstalk):    
    # Set amount left eye leaks into right eye (range 0-1). 
    dp.DPxSetPPx3dCrosstalkLR(crosstalk)    
    dp.DPxWriteRegCache()

def set_crosstalk_left_eye(crosstalk):    
    # Set ammount right eye leaks into left eye (range 0-1). 
    dp.DPxSetPPx3dCrosstalkRL(crosstalk)    
    dp.DPxWriteRegCache()

def initialize_propixx():
    # Initialize Propixx hardware
    dp.DPxOpen()    
    dp.DPxSetPPxDlpSeqPgrm('RB3D')
    dp.DPxWriteRegCache()

def close_propixx():
    # Close Propixx hardware and reset
    dp.DPxSetPPxDlpSeqPgrm('RGB 120Hz')
    dp.DPxWriteRegCache()
    dp.DPxClose()

# Run the function
hello_world_rb3d()