C48: Wide Range, High Bit Depth Colour

%Establish the correct colour and video settings
AssertOpenGL;
PsychImaging('PrepareConfiguration');

%Draw stimuli in 16 bits per colour
PsychImaging('AddTask', 'General', 'FloatingPoint32Bit');

%Enable C48 and set the framebuffer to half the display resolution (no automatic scaling)
PsychImaging('AddTask', 'General', 'EnableDataPixxC48Output', 0);

%If using the PROPixx - uncomment the following to change the sequencer for linearized output (trades off luminance). Make sure to reset to 0 at the end of your script.
%Datapixx('SetPropixxDlpSequenceProgram', 6);
%Datapixx('RegWr');

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

%Set up some position parameters
center = [rect(3)/2, rect(4)/2];
patchHeight = 200;
patchWidth = patchHeight/2; %rescale to half-width, so our final stretched image appears square
patchRect = [center(1) - patchWidth/2,  center(2) - patchHeight/2, ...
            center(1) + patchWidth/2,  center(2) + patchHeight/2];

%Let's pick a random gray level between 0-65535, which is our maximum value at 16 bpc. This must be expressed as a value from 0-1.
maxIntensity = (2^16)-1;
colourValue = randi(maxIntensity)/maxIntensity;
        
%Draw our patch and flip
Screen('FillRect', win, colourValue, patchRect);
Screen('Flip', win);

WaitSecs(4);

%Close window
Screen('Closeall');

#import necessary libraries and modules
from psychopy import core, visual
from psychopy.hardware import keyboard
from pypixxlib import _libdpx as dp
from pypixxlib import shaders
import random

from pypixxlib.propixx import PROPixx
from pypixxlib.viewpixx import VIEWPixx

#In order to set up the shader for C48 mode you will need to specify which VPixx device/display you are using:
myDevice = PROPixx() #comment out if you are using a VIEWPixx
#myDevice = VIEWPixx() #uncomment if you are using a PROPixx

kb = keyboard.Keyboard()

#initialization steps
dp.DPxOpen()
dp.DPxSetVidMode('C48') #set your device/display in C48 video mode 
dp.DPxSetPPxDlpSeqPgrm('RGBHBD') #set RGB high bit depth sequencer mode; do this when displaying on PROPixx to maintain linearity, gamma = 1. Otherwise, comment this line out
dp.DPxWriteRegCache()

#choose a random 16-bit intensity value
random_integer = random.randint(0, 65535)
random_intensity = random_integer/65535

#open your PsychoPy window; note that we specify the colorspace to be 'rgb1' so that RGB values range from 0 to 1. We also explicity set the frame buffer bit depth to 16, by setting depthBits = 16. These steps are necessary for specifying 16-bit values 
win = visual.Window(
        screen = 1,
        monitor =None,
        fullscr=True,
        color='black',
        units = "pix",
        useFBO = True,
        colorSpace='rgb1',
        depthBits=16
        )

#setup the shader for C48 mode
shaders.setUpShaderAndWindow(myDevice, win)

#define the properties of the stimulus patch
square = visual.Rect(
    win=win,
    size=200,
    pos=[0, 0],
    colorSpace='rgb1',
    fillColor = random_intensity
)

#keep flipping the stimulus until the user presses 'escape'
while True:
    square.draw()
    win.flip()

    # Check for escape key press; exit program if 'escape' is pressed
    keys = kb.getKeys()
    if 'escape' in keys:
        break

#close the PsychoPy window and set the video mode back to the default C24 mode
dp.DPxSetVidMode('C24')
dp.DPxWriteRegCache()
win.close()
core.quit()

%Establish the correct colour video settings
AssertOpenGL;

Screen('Preference', 'SkipSyncTests', 1);
PsychImaging('PrepareConfiguration');
PsychImaging('AddTask', 'General', 'FloatingPoint32Bit');

%Our stimuli are circular and hard to scale manually, so we will use mode 2, which averages adjacent pixels to scale the image for us. You can also use mode 1, but mode 2 gives some nice antialiasing around the edges of circular stimuli.
PsychImaging('AddTask', 'General', 'EnableDataPixxC48Output', 2);

%If using the PROPixx - uncomment the following to change the sequencer 
%for linearized output (trades off luminance). Make sure to reset to 0 at
%the end of your script.
%Datapixx('SetPropixxDlpSequenceProgram', 6);
%Datapixx('RegWr');

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

%Set up some parameters
bitDepth = 16;
maxIntensity = 2^bitDepth;
numDots = 400;
radius = 400; %pixels
radiusCenter = [rect(3)/2, rect(4)/2];
dotSize = 10;
theta = (pi*2)/numDots;

%Initialize dot parameters
positions = nan(2,numDots);
colours = nan(3,numDots);

%A simple loop to assign dot positions and create an evenly-spaced red gradient
for k=1:numDots
    positions(1, k) = radius * cos(theta*k);
    positions(2, k) = radius * sin(theta*k);
    colours(:, k) = [((maxIntensity/numDots)*k)/maxIntensity,0,0];
end

%Draw all of our dots and flip
Screen('DrawDots', win, positions, dotSize, colours, radiusCenter, 1);
Screen('Flip', win);

WaitSecs(4);

%Close window
Screen('Closeall');

#import necessary libraries and modules
from psychopy import core, visual
from psychopy.hardware import keyboard
from pypixxlib import _libdpx as dp
from pypixxlib import shaders
import numpy as np

from pypixxlib.propixx import PROPixx
from pypixxlib.viewpixx import VIEWPixx

#In order to set up the shader for C48 mode you will need to specify which VPixx device/display you are using:
myDevice = PROPixx() #comment out if you are using a VIEWPixx
#myDevice = VIEWPixx() #uncomment if you are using a PROPixx

kb = keyboard.Keyboard()

#initialization steps
dp.DPxOpen()
dp.DPxSetVidMode('C48')
dp.DPxSetPPxDlpSeqPgrm('RGBHBD') #set RGB high bit depth sequencer mode; do this when displaying on PROPixx to maintain linearity, gamma = 1. Otherwise, comment this line out
dp.DPxWriteRegCache()

#Set up some parameters
maxIntensity = 65535
numDots = 400
radius = 400
radiusCenter = [0,0]
dotSize = 10
pi = 3.14159265
theta = (pi*2)/numDots

positions = np.zeros((numDots,2))
colors = np.zeros((numDots,3))

#a simple loop to assign dot positions and create an evenly-spaced red gradient
for k in range(numDots) :
    positions[k,0] = radius * np.cos(theta*k)
    positions[k,1] = radius * np.sin(theta*k)
    colors[k,:] =  [((maxIntensity/numDots)*k)/maxIntensity,0,0]

#open your PsychoPy window; note that we specify the colorspace to be 'rgb1' so that RGB values range from 0 to 1. We also explicity set the frame buffer bit depth to 16, by setting depthBits = 16. These steps are necessary for specifying 16-bit values 
win = visual.Window(
        screen = 1,
        monitor =None,
        fullscr=True,
        color='black',
        units = "pix",
        useFBO = True,
        colorSpace='rgb1',
        depthBits=16
        )
        
#setup the shader for C48 mode
shaders.setUpShaderAndWindow(myDevice, win)

#define the properties of the dot stimuli
dots = visual.ElementArrayStim(
    win = win,
    units = "pix",
    elementMask = "circle",
    nElements = numDots,
    xys = positions,
    sizes = dotSize,
    elementTex=None,
    colorSpace='rgb1',
    colors = colors,
)

#keep flipping the stimulus until the user presses 'escape'
while True:
    dots.draw()
    win.flip()

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

#close the PsychoPy window and set the video mode back to the default C24 mode
dp.DPxSetVidMode('C24')
dp.DPxWriteRegCache()
win.close()
core.quit()