def draw(self):
p = self.parameters # shorthand
if p.on:
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
if p.depth_test:
gl.glEnable(gl.GL_DEPTH_TEST)
else:
gl.glDisable(gl.GL_DEPTH_TEST)
if p.polygon_offset_enabled:
gl.glEnable(gl.GL_POLYGON_OFFSET_EXT)
gl.glPolygonOffset(p.polygon_offset_factor, p.polygon_offset_units)
gl.glBindTexture(gl.GL_TEXTURE_1D,self._texture_object_id)
gl.glEnable(gl.GL_TEXTURE_1D)
gl.glDisable(gl.GL_TEXTURE_2D)
if p.bit_depth != self.cached_bit_depth:
self.calculate_bit_depth_dependencies()
# allow max_alpha value to control blending
gl.glEnable( gl.GL_BLEND )
gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA )
if p.color2:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND)
gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2)
## alpha is ignored because the texture base internal format is luminance
else:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
if p.t0_time_sec_absolute is None and not p.ignore_time:
p.t0_time_sec_absolute = VisionEgg.time_func()
w = p.size[0]
inc = w/float(p.num_samples)
if p.ignore_time:
phase = p.phase_at_t0
else:
t_var = VisionEgg.time_func() - p.t0_time_sec_absolute
phase = t_var*p.temporal_freq_hz*-360.0 + p.phase_at_t0
if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance:
self._last_phase = phase # we're re-drawing the phase at this angle
floating_point_sin = numpy.sin(2.0*math.pi*p.spatial_freq*numpy.arange(0.0,w,inc,dtype=numpy.float)+(phase/180.0*math.pi))*0.5*p.contrast+p.pedestal
floating_point_sin = numpy.clip(floating_point_sin,0.0,1.0) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin*self.max_int_val).astype(self.numpy_dtype).tostring()
gl.glTexSubImage1D(gl.GL_TEXTURE_1D, # target
0, # level
0, # x offset
p.num_samples, # width
self.format, # format of new texel data
self.gl_type, # type of new texel data
texel_data) # new texel data
# in the case of only color1,
# the texel data multiplies color1 to produce a color
# with color2,
# the texel data linearly interpolates between color1 and color2
gl.glColor4f(p.color1[0],p.color1[1],p.color1[2],p.max_alpha)
if p.mask:
p.mask.draw_masked_quad_3d(0.0,1.0,0.0,1.0, # for texture coordinates
p.lowerleft,p.lowerright,p.upperright,p.upperleft)
else:
# draw unmasked quad
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0,0.0)
gl.glVertex(*p.lowerleft)
gl.glTexCoord2f(1.0,0.0)
gl.glVertex(*p.lowerright)
gl.glTexCoord2f(1.0,1.0)
gl.glVertex(*p.upperright)
gl.glTexCoord2f(0.0,1.0)
gl.glVertex(*p.upperleft)
gl.glEnd() # GL_QUADS
gl.glDisable(gl.GL_TEXTURE_1D)
if p.polygon_offset_enabled:
gl.glDisable(gl.GL_POLYGON_OFFSET_EXT)
def __init__(self,**kw):
LuminanceGratingCommon.__init__(self,**kw)
p = self.parameters # shorthand
self._texture_object_id = gl.glGenTextures(1)
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
gl.glBindTexture(gl.GL_TEXTURE_1D,self._texture_object_id)
# Do error-checking on texture to make sure it will load
max_dim = gl.glGetIntegerv(gl.GL_MAX_TEXTURE_SIZE)
if p.num_samples > max_dim:
raise NumSamplesTooLargeError("Grating num_samples too large for video system.\nOpenGL reports maximum size of %d"%(max_dim,))
self.calculate_bit_depth_dependencies()
w = p.size[0]
inc = w/float(p.num_samples)
phase = 0.0 # this data won't get used - don't care about phase
self._last_phase = phase
floating_point_sin = numpy.sin(2.0*math.pi*p.spatial_freq*numpy.arange(0.0,w,inc,dtype=numpy.float)+(phase/180.0*math.pi))*0.5*p.contrast+p.pedestal
floating_point_sin = numpy.clip(floating_point_sin,0.0,1.0) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin*self.max_int_val).astype(self.numpy_dtype).tostring()
# Because the MAX_TEXTURE_SIZE method is insensitive to the current
# state of the video system, another check must be done using
# "proxy textures".
gl.glTexImage1D(gl.GL_PROXY_TEXTURE_1D, # target
0, # level
self.gl_internal_format, # video RAM internal format
p.num_samples, # width
0, # border
self.format, # format of texel data
self.gl_type, # type of texel data
texel_data) # texel data (irrelevant for proxy)
if gl.glGetTexLevelParameteriv(gl.GL_PROXY_TEXTURE_1D, # Need PyOpenGL >= 2.0
0,
gl.GL_TEXTURE_WIDTH) == 0:
raise NumSamplesTooLargeError("Grating num_samples is too wide for your video system!")
# If we got here, it worked and we can load the texture for real.
gl.glTexImage1D(gl.GL_TEXTURE_1D, # target
0, # level
self.gl_internal_format, # video RAM internal format
p.num_samples, # width
0, # border
self.format, # format of texel data
self.gl_type, # type of texel data
texel_data) # texel data
# Set texture object defaults
gl.glTexParameteri(gl.GL_TEXTURE_1D,gl.GL_TEXTURE_WRAP_S,gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_1D,gl.GL_TEXTURE_WRAP_T,gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_1D,gl.GL_TEXTURE_MAG_FILTER,gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_1D,gl.GL_TEXTURE_MIN_FILTER,gl.GL_LINEAR)
if p.color2 is not None:
if VisionEgg.Core.gl_renderer == 'ATi Rage 128 Pro OpenGL Engine' and VisionEgg.Core.gl_version == '1.1 ATI-1.2.22':
logger = logging.getLogger('VisionEgg.Gratings')
logger.warning("Your video card and driver have known "
"bugs which prevent them from rendering "
"color gratings properly.")
def draw(self):
p = self.parameters # shorthand
if p.on:
# calculate center
center = VisionEgg._get_center(p.position,p.anchor,p.size)
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
gl.glBindTexture(gl.GL_TEXTURE_1D,self._texture_object_id)
gl.glEnable(gl.GL_TEXTURE_1D)
gl.glDisable(gl.GL_TEXTURE_2D)
if p.bit_depth != self.cached_bit_depth:
self.calculate_bit_depth_dependencies()
# Clear the modeview matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glPushMatrix()
# Rotate about the center of the texture
gl.glTranslate(center[0],
center[1],
0)
gl.glRotate(p.orientation,0,0,1)
if p.depth is None:
gl.glDisable(gl.GL_DEPTH_TEST)
depth = 0.0
else:
gl.glEnable(gl.GL_DEPTH_TEST)
depth = p.depth
# allow max_alpha value to control blending
gl.glEnable( gl.GL_BLEND )
gl.glBlendFunc( gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA )
if p.color2:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND)
gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2)
## alpha is ignored because the texture base internal format is luminance
else:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
if p.t0_time_sec_absolute is None and not p.ignore_time:
p.t0_time_sec_absolute = VisionEgg.time_func()
w = p.size[0]
inc = w/float(p.num_samples)
if p.ignore_time:
phase = p.phase_at_t0
else:
t_var = VisionEgg.time_func() - p.t0_time_sec_absolute
phase = t_var*p.temporal_freq_hz*-360.0 + p.phase_at_t0
if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance:
self._last_phase = phase # we're re-drawing the phase at this angle
floating_point_sin = numpy.sin(2.0*math.pi*p.spatial_freq*numpy.arange(0.0,w,inc,dtype=numpy.float)+(phase/180.0*math.pi))*0.5*p.contrast+p.pedestal
floating_point_sin = numpy.clip(floating_point_sin,0.0,1.0) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin*self.max_int_val).astype(self.numpy_dtype)
# PyOpenGL 2.0.1.09 has a bug, so use our own wrapper
_vegl.veglTexSubImage1D(gl.GL_TEXTURE_1D, # target
0, # level
0, # x offset
p.num_samples, # width
self.format, # format of new texel data
self.gl_type, # type of new texel data
texel_data) # new texel data
if 0:
compare_array = numpy.empty(texel_data.shape,dtype=texel_data.dtype)
pixels = _vegl.veglGetTexImage(gl.GL_TEXTURE_1D, # target
0, # level
self.format, # format
self.gl_type, # type
compare_array)
assert numpy.allclose( compare_array, texel_data )
h_w = p.size[0]/2.0
h_h = p.size[1]/2.0
l = -h_w
r = h_w
b = -h_h
t = h_h
# in the case of only color1,
# the texel data multiplies color1 to produce a color
# with color2,
# the texel data linearly interpolates between color1 and color2
gl.glColor4f(p.color1[0],p.color1[1],p.color1[2],p.max_alpha)
if p.mask:
p.mask.draw_masked_quad(0.0,1.0,0.0,1.0, # l,r,b,t for texture coordinates
l,r,b,t, # l,r,b,t in eye coordinates
depth ) # also in eye coordinates
else:
# draw unmasked quad
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0,0.0)
gl.glVertex3f(l,b,depth)
gl.glTexCoord2f(1.0,0.0)
gl.glVertex3f(r,b,depth)
gl.glTexCoord2f(1.0,1.0)
gl.glVertex3f(r,t,depth)
gl.glTexCoord2f(0.0,1.0)
gl.glVertex3f(l,t,depth)
gl.glEnd() # GL_QUADS
gl.glDisable(gl.GL_TEXTURE_1D)
gl.glPopMatrix()
def draw(self):
p = self.parameters # shorthand
if p.on:
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
if p.depth_test:
gl.glEnable(gl.GL_DEPTH_TEST)
else:
gl.glDisable(gl.GL_DEPTH_TEST)
if p.polygon_offset_enabled:
gl.glEnable(gl.GL_POLYGON_OFFSET_EXT)
gl.glPolygonOffset(p.polygon_offset_factor, p.polygon_offset_units)
gl.glBindTexture(gl.GL_TEXTURE_1D, self._texture_object_id)
gl.glEnable(gl.GL_TEXTURE_1D)
gl.glDisable(gl.GL_TEXTURE_2D)
if p.bit_depth != self.cached_bit_depth:
self.calculate_bit_depth_dependencies()
# allow max_alpha value to control blending
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
if p.color2:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND)
gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2)
## alpha is ignored because the texture base internal format is luminance
else:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
if p.t0_time_sec_absolute is None and not p.ignore_time:
p.t0_time_sec_absolute = VisionEgg.time_func()
w = p.size[0]
inc = w / float(p.num_samples)
if p.ignore_time:
phase = p.phase_at_t0
else:
t_var = VisionEgg.time_func() - p.t0_time_sec_absolute
phase = t_var * p.temporal_freq_hz * -360.0 + p.phase_at_t0
if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance:
self._last_phase = phase # we're re-drawing the phase at this angle
floating_point_sin = (
numpy.sin(
2.0 * math.pi * p.spatial_freq * numpy.arange(0.0, w, inc, dtype=numpy.float)
+ (phase / 180.0 * math.pi)
)
* 0.5
* p.contrast
+ p.pedestal
)
floating_point_sin = numpy.clip(
floating_point_sin, 0.0, 1.0
) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin * self.max_int_val).astype(self.numpy_dtype).tostring()
gl.glTexSubImage1D(
gl.GL_TEXTURE_1D, # target
0, # level
0, # x offset
p.num_samples, # width
self.format, # format of new texel data
self.gl_type, # type of new texel data
texel_data,
) # new texel data
# in the case of only color1,
# the texel data multiplies color1 to produce a color
# with color2,
# the texel data linearly interpolates between color1 and color2
gl.glColor4f(p.color1[0], p.color1[1], p.color1[2], p.max_alpha)
if p.mask:
p.mask.draw_masked_quad_3d(
0.0, 1.0, 0.0, 1.0, p.lowerleft, p.lowerright, p.upperright, p.upperleft # for texture coordinates
)
else:
# draw unmasked quad
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0, 0.0)
gl.glVertex(*p.lowerleft)
gl.glTexCoord2f(1.0, 0.0)
gl.glVertex(*p.lowerright)
gl.glTexCoord2f(1.0, 1.0)
gl.glVertex(*p.upperright)
gl.glTexCoord2f(0.0, 1.0)
gl.glVertex(*p.upperleft)
gl.glEnd() # GL_QUADS
gl.glDisable(gl.GL_TEXTURE_1D)
if p.polygon_offset_enabled:
gl.glDisable(gl.GL_POLYGON_OFFSET_EXT)
def __init__(self, **kw):
LuminanceGratingCommon.__init__(self, **kw)
p = self.parameters # shorthand
self._texture_object_id = gl.glGenTextures(1)
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
gl.glBindTexture(gl.GL_TEXTURE_1D, self._texture_object_id)
# Do error-checking on texture to make sure it will load
max_dim = gl.glGetIntegerv(gl.GL_MAX_TEXTURE_SIZE)
if p.num_samples > max_dim:
raise NumSamplesTooLargeError(
"Grating num_samples too large for video system.\nOpenGL reports maximum size of %d" % (max_dim,)
)
self.calculate_bit_depth_dependencies()
w = p.size[0]
inc = w / float(p.num_samples)
phase = 0.0 # this data won't get used - don't care about phase
self._last_phase = phase
floating_point_sin = (
numpy.sin(
2.0 * math.pi * p.spatial_freq * numpy.arange(0.0, w, inc, dtype=numpy.float)
+ (phase / 180.0 * math.pi)
)
* 0.5
* p.contrast
+ p.pedestal
)
floating_point_sin = numpy.clip(floating_point_sin, 0.0, 1.0) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin * self.max_int_val).astype(self.numpy_dtype).tostring()
# Because the MAX_TEXTURE_SIZE method is insensitive to the current
# state of the video system, another check must be done using
# "proxy textures".
gl.glTexImage1D(
gl.GL_PROXY_TEXTURE_1D, # target
0, # level
self.gl_internal_format, # video RAM internal format
p.num_samples, # width
0, # border
self.format, # format of texel data
self.gl_type, # type of texel data
texel_data,
) # texel data (irrelevant for proxy)
if gl.glGetTexLevelParameteriv(gl.GL_PROXY_TEXTURE_1D, 0, gl.GL_TEXTURE_WIDTH) == 0: # Need PyOpenGL >= 2.0
raise NumSamplesTooLargeError("Grating num_samples is too wide for your video system!")
# If we got here, it worked and we can load the texture for real.
gl.glTexImage1D(
gl.GL_TEXTURE_1D, # target
0, # level
self.gl_internal_format, # video RAM internal format
p.num_samples, # width
0, # border
self.format, # format of texel data
self.gl_type, # type of texel data
texel_data,
) # texel data
# Set texture object defaults
gl.glTexParameteri(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_WRAP_S, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_WRAP_T, gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
gl.glTexParameteri(gl.GL_TEXTURE_1D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
if p.color2 is not None:
if (
VisionEgg.Core.gl_renderer == "ATi Rage 128 Pro OpenGL Engine"
and VisionEgg.Core.gl_version == "1.1 ATI-1.2.22"
):
logger = logging.getLogger("VisionEgg.Gratings")
logger.warning(
"Your video card and driver have known "
"bugs which prevent them from rendering "
"color gratings properly."
)
def draw(self):
p = self.parameters # shorthand
if p.on:
# calculate center
center = VisionEgg._get_center(p.position, p.anchor, p.size)
if p.mask:
gl.glActiveTextureARB(gl.GL_TEXTURE0_ARB)
gl.glBindTexture(gl.GL_TEXTURE_1D, self._texture_object_id)
gl.glEnable(gl.GL_TEXTURE_1D)
gl.glDisable(gl.GL_TEXTURE_2D)
if p.bit_depth != self.cached_bit_depth:
self.calculate_bit_depth_dependencies()
# Clear the modeview matrix
gl.glMatrixMode(gl.GL_MODELVIEW)
gl.glPushMatrix()
# Rotate about the center of the texture
gl.glTranslate(center[0], center[1], 0)
gl.glRotate(p.orientation, 0, 0, 1)
if p.depth is None:
gl.glDisable(gl.GL_DEPTH_TEST)
depth = 0.0
else:
gl.glEnable(gl.GL_DEPTH_TEST)
depth = p.depth
# allow max_alpha value to control blending
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
if p.color2:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_BLEND)
gl.glTexEnvfv(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_COLOR, p.color2)
## alpha is ignored because the texture base internal format is luminance
else:
gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE)
if p.t0_time_sec_absolute is None and not p.ignore_time:
p.t0_time_sec_absolute = VisionEgg.time_func()
w = p.size[0]
inc = w / float(p.num_samples)
if p.ignore_time:
phase = p.phase_at_t0
else:
t_var = VisionEgg.time_func() - p.t0_time_sec_absolute
phase = t_var * p.temporal_freq_hz * -360.0 + p.phase_at_t0
if p.recalculate_phase_tolerance is None or abs(self._last_phase - phase) > p.recalculate_phase_tolerance:
self._last_phase = phase # we're re-drawing the phase at this angle
floating_point_sin = (
numpy.sin(
2.0 * math.pi * p.spatial_freq * numpy.arange(0.0, w, inc, dtype=numpy.float)
+ (phase / 180.0 * math.pi)
)
* 0.5
* p.contrast
+ p.pedestal
)
floating_point_sin = numpy.clip(
floating_point_sin, 0.0, 1.0
) # allow square wave generation if contrast > 1
texel_data = (floating_point_sin * self.max_int_val).astype(self.numpy_dtype)
# PyOpenGL 2.0.1.09 has a bug, so use our own wrapper
_vegl.veglTexSubImage1D(
gl.GL_TEXTURE_1D, # target
0, # level
0, # x offset
p.num_samples, # width
self.format, # format of new texel data
self.gl_type, # type of new texel data
texel_data,
) # new texel data
if 0:
compare_array = numpy.empty(texel_data.shape, dtype=texel_data.dtype)
pixels = _vegl.veglGetTexImage(
gl.GL_TEXTURE_1D, # target
0, # level
self.format, # format
self.gl_type, # type
compare_array,
)
assert numpy.allclose(compare_array, texel_data)
h_w = p.size[0] / 2.0
h_h = p.size[1] / 2.0
l = -h_w
r = h_w
b = -h_h
t = h_h
# in the case of only color1,
# the texel data multiplies color1 to produce a color
# with color2,
# the texel data linearly interpolates between color1 and color2
gl.glColor4f(p.color1[0], p.color1[1], p.color1[2], p.max_alpha)
if p.mask:
p.mask.draw_masked_quad(
0.0,
1.0,
0.0,
1.0, # l,r,b,t for texture coordinates
l,
r,
b,
t, # l,r,b,t in eye coordinates
depth,
) # also in eye coordinates
else:
# draw unmasked quad
gl.glBegin(gl.GL_QUADS)
gl.glTexCoord2f(0.0, 0.0)
gl.glVertex3f(l, b, depth)
gl.glTexCoord2f(1.0, 0.0)
gl.glVertex3f(r, b, depth)
gl.glTexCoord2f(1.0, 1.0)
gl.glVertex3f(r, t, depth)
gl.glTexCoord2f(0.0, 1.0)
gl.glVertex3f(l, t, depth)
gl.glEnd() # GL_QUADS
gl.glDisable(gl.GL_TEXTURE_1D)
gl.glPopMatrix()