def __init__(self,
parent,
shared,
trigger_pixel,
T=30.0,
N_phi=64,
N_z=-1,
delta_s=1,
contrast=250.):
sampling_phi = 180. / int(N_phi)
if int(
N_z
) == -1: # -1 means: automatically round such that pixel are appoximately squares
N_z_ = np.float(26. / (sampling_phi / 360. * 2 * np.pi * 10))
N_z = np.round(N_z_, 2).astype(np.int)
print("Number of pixels in elevation: " + str(N_z_) +
", rounded to: " + str(N_z))
else:
N_z = int(N_z)
arg = (T, N_phi, N_z, delta_s, contrast)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = [
'duration', 'N_phi', 'N_z', 'delta_sample', 'contrast'
]
self.T = float(T) # duration
self.N_phi = int(N_phi) # number of pixels along azimuth
self.N_z = int(N_z)
self.delta_s = int(delta_s)
self.contrast = float(contrast)
def __init__(self, parent, shared, trigger_pixel, T=10., intensity=125.):
arg = (T, intensity)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ['time', 'intensity']
# define parameters
self.intensity = float(intensity)
self.T = float(T)
self.shared.arena_mode = 'default'
def __init__(self, parent, shared, trigger_pixel, T=10.0, velocity=5.0):
arg = (T, velocity)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ['stimulus duration [s]', 'velocity']
# define parameters
self.T = float(T) # duration [sec]
self.velocity = float(velocity)
self.shared.arena_mode = 'default'
def __init__(self,
parent,
shared,
trigger_pixel,
rotation=90.0,
wave_length=10.0,
velocity=10.0,
mode='sq',
min_intensity=0,
max_intensity=255,
bg_intensity=51,
motion_T=3.0,
pause=0.5,
phi=90,
dphi=20.,
z=0,
dz=2):
arg = (rotation, wave_length, velocity, mode, min_intensity,
max_intensity, bg_intensity, motion_T, pause, phi, dphi, z, dz)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = [
'rotation [deg]', 'wavelength [deg]', 'velocity [deg/sec]',
'mode [sq/sin]', 'min_intensity', 'max_intensity', 'bg_intensity',
'time of motion [sec]', 'pause time [sec]', 'phi [deg]',
'dphi [deg]', 'z [cm]', 'dz [cm]'
]
self.rotation = float(rotation) # rotation (degree)
self.wave_length = float(wave_length) # wave length (degree)
self.velocity = float(
velocity) # velocity (degree / second (assumption: 60 Hz fps) )
self.mode = str(mode) # grating type
self.min_intensity = float(min_intensity) # minimum intensity value
self.max_intensity = float(max_intensity) # maximum intensity value
self.motion_T = float(motion_T) # motion time
self.pause = float(pause) # pause length
self.phi = int(float(phi)) # position of window in azimuth
self.dphi = int(float(dphi)) # size of window in azimuth
self.z = float(
z) # position of window in z-axis (cylindric coordinates)
self.dz = float(dz) # size of window in z-axis (cylindric coordinates)
self.bg_intensity = float(
bg_intensity) / 3 # background intensity value
# divide by three because of the layered structure of the 3-color-world structure of the 180Hz-fps arena
# because of the MBlend-Texture Mode the overlaying textures of the 3 parallel color worlds are added up internally
self.shared.arena_mode = 'monitored'
def __init__(self,
parent,
shared,
trigger_pixel,
T=5,
N_steps=5,
dt=0.5,
phi0=90.,
z0=0.,
direction=45.,
width=10.,
height=40.,
step_length=20,
c_on=255,
c_off=0,
c_bg=125):
self.sampling_phi = 0.5 # degrees per pixel (will be true for both phi and z)
self.N_phi = np.round(180 / self.sampling_phi).astype(np.int)
# automatically round N_z such that pixel are appoximately squares
N_z_ = np.float(26. / (self.sampling_phi / 360. * 2 * np.pi * 10))
N_z = np.round(N_z_, 2).astype(np.int)
print("Number of pixels in elevation: " + str(N_z_) +
", rounded to: " + str(N_z))
self.N_z = N_z
arg = (T, N_steps, dt, phi0, z0, direction, width, height, step_length,
c_on, c_off, c_bg)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = [
"stimulus_duration", "N_steps", "dt", "phi0", "z0", "direction",
"width", "height", "step_length", "c_on", "c_off", "c_bg"
]
#self.T = float(int(N_steps)*float(dt)) # duration
self.T = float(T) # duration
self.N_steps = int(N_steps)
self.dt = float(dt)
self.phi0 = float(phi0)
self.z0 = float(z0)
self.direction = float(direction)
self.width = float(width)
self.height = float(height)
self.step_length = float(step_length)
self.c_on = int(float(c_on))
self.c_off = int(float(c_off))
self.c_bg = int(float(c_bg))
def __init__(self, parent, shared, trigger_pixel, T = 2., multiple = 1., min_intensity = 0, max_intensity = 100, color = 'b'):
arg = (T, multiple, min_intensity, max_intensity, color)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ["stimulus duration [sec]", "multiple", "min_intensity", "max_intensity", "color"]
# define parameters
self.T = float(T) # stimulus duration in seconds (length of the whole stimulus)
self.color = str(color) # color of the arena
self.multiple = float(int(float(multiple))) # flash duration (length of the pulse in multiples of frames)
self.min_intensity = float(min_intensity) # minimum intensity (during start pause)
self.max_intensity = float(max_intensity) # maximum intensity (first after stimulus onset)
self.shared.arena_mode = 'default'
def __init__(self, parent, shared, trigger_pixel, velocity = 30.0, dphi = 10.0, z = 0.0, dz = 2.0, bar_intensity = 255.0, bg_intensity=0.0):
arg = (velocity, dphi, z, dz, bar_intensity, bg_intensity)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ['velocity [deg/sec]', 'dphi [deg]', 'z [cm]', 'dz [cm]', 'intensity', 'bg_intensity']
# define parameters
self.velocity = float(velocity) # velocity of the bar in [deg/sec]
self.dphi = float(dphi) # size of the bar in azimuth
self.z = float(z) # position of the bar in z-axis (cylindric coordinates)
self.dz = float(dz) # size of the bar on z-axis (cylindric coordinates)
self.bar_intensity = float(bar_intensity) # bar intensity value
self.bg_intensity = float(bg_intensity) # background intensity value
self.shared.arena_mode = 'default'
def __init__(self, parent, shared, trigger_pixel, T = 10.0, rotation = 0.0, wave_length = 30.0 , velocity = 10.0, min_intensity = 0, max_intensity = 255):
arg = (T, rotation, wave_length, velocity, min_intensity, max_intensity)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ['stimulus duration [s]', 'rotation [deg]', 'wavelength [deg]', 'velocity [deg/s]', 'min_intensity', 'max_intensity']
# define parameters
self.T = float(T) # duration [sec]
self.rotation = float(rotation) # rotation (degree)
self.wave_length = float(wave_length) # wave length (degree)
self.velocity = float(velocity) # velocity (degree / second (assumption: 60 Hz fps) )
self.min_intensity = float(min_intensity)/2. # min intensity
self.max_intensity = float(max_intensity)/2. # max intensity
self.shared.arena_mode = 'default'
def __init__(self, parent, shared, trigger_pixel, duration, N_horizontal):
arg = (duration, N_horizontal)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define stimulus name
self.name = "calibration"
# define parameter names
self.parameter_names = ['duration [sec]', 'N_horizontal']
# define geometry name
self.geometry_name = 'calibration'
# define parameters
self.duration = float(duration)
self.N_horizontal = float(N_horizontal)
def __init__(self, parent, shared, trigger_pixel, T = 10.0, wave_length = 30.0 , velocity = 10.0, mode = 'sq', min_intensity = 0, max_intensity = 255, phi = 90., phase_offset = 0.):
arg = (T, wave_length, velocity, mode, min_intensity, max_intensity, phi, phase_offset)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = ['stimulus duration [s]', 'wavelength [deg]', 'velocity [deg/s]', 'mode [sq/sin]', 'min_intensity', 'max_intensity', 'phi', 'phase_offset']
# define parameters
self.T = float(T) # duration [sec]
self.rotation = float(0.0) # rotation (degree)
self.wave_length = float(wave_length) # wave length (degree)
self.velocity = float(velocity) # velocity (degree / second (assumption: 60 Hz fps) )
self.mode = str(mode) # grating type
self.min_intensity = float(min_intensity) # min intensity
self.max_intensity = float(max_intensity) # max intensity
self.phi = float(phi) # receptive field position
self.phase_offset = float(phase_offset) # relative phase offset to the receptive field center
self.shared.arena_mode = 'default'
def __init__(self,
parent,
shared,
trigger_pixel,
T=10.0,
phase_length=1.0,
min_intensity=0,
max_intensity=255,
bg_intensity=51,
phi=90,
dphi=20.,
z=0,
dz=2):
arg = (T, phase_length, min_intensity, max_intensity, bg_intensity,
phi, dphi, z, dz)
StimulusBuilder.__init__(self, parent, shared, trigger_pixel, arg)
# define parameter names
self.parameter_names = [
'stimulus duration [sec]', 'pulse length [sec]', 'min_intensity',
'max_intensity', 'background color', 'phi [deg]', 'dphi [deg]',
'z [cm]', 'dz [cm]'
]
# define parameters
self.T = float(T) # duration [sec]
self.phase_length = float(phase_length)
self.max_intensity = float(max_intensity)
self.bg_intensity = float(bg_intensity)
self.min_intensity = float(min_intensity)
self.phi = int(float(phi))
self.dphi = int(float(dphi))
self.z = float(z)
self.dz = float(dz)
self.shared.arena_mode = 'monitored'