def initialize(self, x=None, y=None, color=None, point_size=1.0,
position=None, nprimitives=None, index=None,
color_array_index=None, thickness=None,
options=None, autocolor=None):
# if position is specified, it contains x and y as column vectors
if position is not None:
position = np.array(position, dtype=np.float32)
if thickness:
shape = (2 * position.shape[0], 1)
else:
shape = (1, position.shape[0])
else:
position, shape = process_coordinates(x=x, y=y)
if thickness:
shape = (shape[0], 2 * shape[1])
# register the size of the data
self.size = np.prod(shape)
# there is one plot per row
if not nprimitives:
nprimitives = shape[0]
nsamples = shape[1]
else:
nsamples = self.size // nprimitives
# handle thickness
if thickness and position.shape[0] >= 2:
w = thickness
n = self.size
X = position
Y = np.zeros((n, 2))
u = np.zeros((n/2, 2))
X2 = np.vstack((X, 2*X[-1,:]-X[-2,:]))
u[:,0] = -np.diff(X2[:,1])
u[:,1] = np.diff(X2[:,0])
r = (u[:,0] ** 2 + u[:,1] ** 2) ** .5
rm = r.mean()
r[r == 0.] = rm
# print u
# print r
# ind = np.nonzero(r == 0.)[0]
# print ind, ind-1
# r[ind] = r[ind - 1]
u[:,0] /= r
u[:,1] /= r
Y[::2,:] = X - w * u
Y[1::2,:] = X + w * u
position = Y
x = Y[:,0]
y = Y[:,1]
# print x
# print y
self.primitive_type = 'TRIANGLE_STRIP'
# register the bounds
if nsamples <= 1:
self.bounds = [0, self.size]
else:
self.bounds = np.arange(0, self.size + 1, nsamples)
# normalize position
# if viewbox:
# self.add_normalizer('position', viewbox)
# by default, use the default color
if color is None:
if nprimitives <= 1:
color = self.default_color
# automatic color with color map
if autocolor is not None:
if nprimitives <= 1:
color = get_next_color(autocolor)
else:
color = [get_next_color(i + autocolor) for i in xrange(nprimitives)]
# # handle the case where the color is a string where each character
# # is a color (eg. 'ry')
# if isinstance(color, basestring):
# color = list(color)
color = get_color(color)
# handle the case where there is a single color given as a list of
# RGB components instead of a tuple
if type(color) is list:
if color and (type(color[0]) != tuple) and (3 <= len(color) <= 4):
color = tuple(color)
else:
color = np.array(color)
# first, initialize use_color_array to False except if
# color_array_index is not None
use_color_array = color_array_index is not None
if isinstance(color, np.ndarray):
colors_ndim = color.shape[1]
# first case: one color per point
if color.shape[0] == self.size:
single_color = False
# second case: use a color array so that each plot has a single
# color, this saves memory since there is a single color in
# memory for any plot
else:
use_color_array = True
single_color = False
elif type(color) is tuple:
single_color = True
colors_ndim = len(color)
# set position attribute
self.add_attribute("position", ndim=2, data=position, autonormalizable=True)
if index is not None:
index = np.array(index)
# self.size = len(index)
self.add_index("index", data=index)
# single color case: no need for a color buffer, just use default color
if single_color and not use_color_array:
self.add_uniform("color", ndim=colors_ndim, data=color)
if colors_ndim == 3:
self.add_fragment_main("""
out_color = vec4(color, 1.0);
""")
elif colors_ndim == 4:
self.add_fragment_main("""
out_color = color;
""")
# multiple colors case: color attribute
elif not use_color_array:
self.add_attribute("color", ndim=colors_ndim, data=color)
self.add_varying("varying_color", vartype="float", ndim=colors_ndim)
self.add_vertex_main("""
varying_color = color;
""")
if colors_ndim == 3:
self.add_fragment_main("""
out_color = vec4(varying_color, 1.0);
""")
elif colors_ndim == 4:
self.add_fragment_main("""
out_color = varying_color;
""")
# multiple colors, but with a color array to save memory
elif use_color_array:
if color_array_index is None:
color_array_index = np.repeat(np.arange(nprimitives), nsamples)
color_array_index = np.array(color_array_index)
ncolors = color.shape[0]
ncomponents = color.shape[1]
color = color.reshape((1, ncolors, ncomponents))
dx = 1. / ncolors
offset = dx / 2.
self.add_texture('colormap', ncomponents=ncomponents, ndim=1, data=color)
self.add_attribute('index', ndim=1, vartype='int', data=color_array_index)
self.add_varying('vindex', vartype='int', ndim=1)
self.add_vertex_main("""
vindex = index;
""")
self.add_fragment_main("""
float coord = %.5f + vindex * %.5f;
vec4 color = texture1D(colormap, coord);
out_color = color;
""" % (offset, dx))
# add point size uniform (when it's not specified, there might be some
# bugs where its value is obtained from other datasets...)
self.add_uniform("point_size", data=point_size)
self.add_vertex_main("""gl_PointSize = point_size;""")
def initialize(self, x=None, y=None, color=None, autocolor=None,
texture=None, position=None):#, normalize=None):
# if position is specified, it contains x and y as column vectors
if position is not None:
position = np.array(position, dtype=np.float32)
# shape = (position.shape[0], 1)
else:
position, shape = process_coordinates(x=x, y=y)
texsize = float(max(texture.shape[:2]))
shape = texture.shape
ncomponents = texture.shape[2]
self.size = position.shape[0]
if shape[0] == 1:
self.ndim = 1
elif shape[0] > 1:
self.ndim = 2
self.primitive_type = 'POINTS'
# normalize position
# if viewbox:
# self.add_normalizer('position', viewbox)
# self.normalize = normalize
# default color
if color is None:
color = self.default_color
# automatic color with color map
if autocolor is not None:
color = get_next_color(autocolor)
color = get_color(color)
# handle the case where there is a single color given as a list of
# RGB components instead of a tuple
if type(color) is list:
if color and (type(color[0]) != tuple) and (3 <= len(color) <= 4):
color = tuple(color)
else:
color = np.array(color)
if isinstance(color, np.ndarray):
colors_ndim = color.shape[1]
# one color per point
single_color = False
elif type(color) is tuple:
single_color = True
colors_ndim = len(color)
texture_shader = """
out_color = texture%NDIM%(tex_sampler, gl_PointCoord%POINTCOORD%) * %COLOR%;
"""
shader_ndim = "%dD" % self.ndim
if self.ndim == 1:
shader_pointcoord = ".x"
else:
shader_pointcoord = ""
# single color case: no need for a color buffer, just use default color
if single_color:
self.add_uniform("color", ndim=colors_ndim, data=color)
shader_color_name = "color"
# multiple colors case: color attribute
else:
self.add_attribute("color", ndim=colors_ndim, data=color)
self.add_varying("varying_color", vartype="float", ndim=colors_ndim)
self.add_vertex_main("""
varying_color = color;
""")
shader_color_name = "varying_color"
if colors_ndim == 3:
shader_color = "vec4(%s, 1.0)" % shader_color_name
elif colors_ndim == 4:
shader_color = shader_color_name
texture_shader = texture_shader.replace('%COLOR%', shader_color)
texture_shader = texture_shader.replace('%NDIM%', shader_ndim)
texture_shader = texture_shader.replace('%POINTCOORD%', shader_pointcoord)
self.add_fragment_main(texture_shader)
# add variables
self.add_attribute("position", vartype="float", ndim=2, data=position,
autonormalizable=True)
self.add_texture("tex_sampler", size=shape, ndim=self.ndim,
ncomponents=ncomponents)
self.add_compound("texture", fun=lambda texture: \
dict(tex_sampler=texture), data=texture)
self.add_uniform("point_size", vartype="float", ndim=1, data=texsize)
# Vertex shader
self.add_vertex_main("""
gl_PointSize = point_size;
""")
def initialize(self, x=None, y=None, color=None, point_size=1.0,
position=None, nprimitives=None, index=None,
color_array_index=None, channel_height=CHANNEL_HEIGHT,
options=None, autocolor=None):
position, shape = process_coordinates(x=x, y=y)
# register the size of the data
self.size = np.prod(shape)
# there is one plot per row
if not nprimitives:
nprimitives = shape[0]
nsamples = shape[1]
else:
nsamples = self.size // nprimitives
# register the bounds
if nsamples <= 1:
self.bounds = [0, self.size]
else:
self.bounds = np.arange(0, self.size + 1, nsamples)
# automatic color with color map
if autocolor is not None:
if nprimitives <= 1:
color = get_next_color(autocolor)
else:
color = np.array([get_next_color(i + autocolor) for i in xrange(nprimitives)])
# set position attribute
self.add_attribute("position0", ndim=2, data=position, autonormalizable=True)
index = np.array(index)
self.add_index("index", data=index)
if color_array_index is None:
color_array_index = np.repeat(np.arange(nprimitives), nsamples)
color_array_index = np.array(color_array_index)
ncolors = color.shape[0]
ncomponents = color.shape[1]
color = color.reshape((1, ncolors, ncomponents))
dx = 1. / ncolors
offset = dx / 2.
self.add_texture('colormap', ncomponents=ncomponents, ndim=1, data=color)
self.add_attribute('index', ndim=1, vartype='int', data=color_array_index)
self.add_varying('vindex', vartype='int', ndim=1)
self.add_uniform('nchannels', vartype='float', ndim=1, data=float(nprimitives))
self.add_uniform('channel_height', vartype='float', ndim=1, data=channel_height)
self.add_vertex_main("""
vec2 position = position0;
position.y = channel_height * position.y + .9 * (2 * index - (nchannels - 1)) / (nchannels - 1);
vindex = index;
""")
self.add_fragment_main("""
float coord = %.5f + vindex * %.5f;
vec4 color = texture1D(colormap, coord);
out_color = color;
""" % (offset, dx))
# add point size uniform (when it's not specified, there might be some
# bugs where its value is obtained from other datasets...)
self.add_uniform("point_size", data=point_size)
self.add_vertex_main("""gl_PointSize = point_size;""")
def initialize(self,
x=None,
y=None,
color=None,
point_size=1.0,
position=None,
nprimitives=None,
index=None,
color_array_index=None,
thickness=None,
options=None,
autocolor=None):
# if position is specified, it contains x and y as column vectors
if position is not None:
position = np.array(position, dtype=np.float32)
if thickness:
shape = (2 * position.shape[0], 1)
else:
shape = (1, position.shape[0])
else:
position, shape = process_coordinates(x=x, y=y)
if thickness:
shape = (shape[0], 2 * shape[1])
# register the size of the data
self.size = np.prod(shape)
# there is one plot per row
if not nprimitives:
nprimitives = shape[0]
nsamples = shape[1]
else:
nsamples = self.size // nprimitives
# handle thickness
if thickness and position.shape[0] >= 2:
w = thickness
n = self.size
X = position
Y = np.zeros((n, 2))
u = np.zeros((n / 2, 2))
X2 = np.vstack((X, 2 * X[-1, :] - X[-2, :]))
u[:, 0] = -np.diff(X2[:, 1])
u[:, 1] = np.diff(X2[:, 0])
r = (u[:, 0]**2 + u[:, 1]**2)**.5
rm = r.mean()
r[r == 0.] = rm
# print u
# print r
# ind = np.nonzero(r == 0.)[0]
# print ind, ind-1
# r[ind] = r[ind - 1]
u[:, 0] /= r
u[:, 1] /= r
Y[::2, :] = X - w * u
Y[1::2, :] = X + w * u
position = Y
x = Y[:, 0]
y = Y[:, 1]
# print x
# print y
self.primitive_type = 'TRIANGLE_STRIP'
# register the bounds
if nsamples <= 1:
self.bounds = [0, self.size]
else:
self.bounds = np.arange(0, self.size + 1, nsamples)
# normalize position
# if viewbox:
# self.add_normalizer('position', viewbox)
# by default, use the default color
if color is None:
if nprimitives <= 1:
color = self.default_color
# automatic color with color map
if autocolor is not None:
if nprimitives <= 1:
color = get_next_color(autocolor)
else:
color = [
get_next_color(i + autocolor) for i in range(nprimitives)
]
# # handle the case where the color is a string where each character
# # is a color (eg. 'ry')
# if isinstance(color, basestring):
# color = list(color)
color = get_color(color)
# handle the case where there is a single color given as a list of
# RGB components instead of a tuple
if type(color) is list:
if color and (type(color[0]) != tuple) and (3 <= len(color) <= 4):
color = tuple(color)
else:
color = np.array(color)
# first, initialize use_color_array to False except if
# color_array_index is not None
use_color_array = color_array_index is not None
if isinstance(color, np.ndarray):
colors_ndim = color.shape[1]
# first case: one color per point
if color.shape[0] == self.size:
single_color = False
# second case: use a color array so that each plot has a single
# color, this saves memory since there is a single color in
# memory for any plot
else:
use_color_array = True
single_color = False
elif type(color) is tuple:
single_color = True
colors_ndim = len(color)
# set position attribute
self.add_attribute("position",
ndim=2,
data=position,
autonormalizable=True)
if index is not None:
index = np.array(index)
# self.size = len(index)
self.add_index("index", data=index)
# single color case: no need for a color buffer, just use default color
if single_color and not use_color_array:
self.add_uniform("color", ndim=colors_ndim, data=color)
if colors_ndim == 3:
self.add_fragment_main("""
out_color = vec4(color, 1.0);
""")
elif colors_ndim == 4:
self.add_fragment_main("""
out_color = color;
""")
# multiple colors case: color attribute
elif not use_color_array:
self.add_attribute("color", ndim=colors_ndim, data=color)
self.add_varying("varying_color",
vartype="float",
ndim=colors_ndim)
self.add_vertex_main("""
varying_color = color;
""")
if colors_ndim == 3:
self.add_fragment_main("""
out_color = vec4(varying_color, 1.0);
""")
elif colors_ndim == 4:
self.add_fragment_main("""
out_color = varying_color;
""")
# multiple colors, but with a color array to save memory
elif use_color_array:
if color_array_index is None:
color_array_index = np.repeat(np.arange(nprimitives), nsamples)
color_array_index = np.array(color_array_index)
ncolors = color.shape[0]
ncomponents = color.shape[1]
color = color.reshape((1, ncolors, ncomponents))
dx = 1. / ncolors
offset = dx / 2.
self.add_texture('colormap',
ncomponents=ncomponents,
ndim=1,
data=color)
self.add_attribute('index',
ndim=1,
vartype='int',
data=color_array_index)
self.add_varying('vindex', vartype='int', ndim=1)
self.add_vertex_main("""
vindex = index;
""")
self.add_fragment_main("""
float coord = %.5f + vindex * %.5f;
vec4 color = texture1D(colormap, coord);
out_color = color;
""" % (offset, dx))
# add point size uniform (when it's not specified, there might be some
# bugs where its value is obtained from other datasets...)
self.add_uniform("point_size", data=point_size)
self.add_vertex_main("""gl_PointSize = point_size;""")
def initialize(self, x=None, y=None, color=None, point_size=1.0,
position=None, nprimitives=None, index=None,
color_array_index=None, channel_height=CHANNEL_HEIGHT,
options=None, autocolor=None):
position, shape = process_coordinates(x=x, y=y)
# register the size of the data
self.size = np.prod(shape)
# there is one plot per row
if not nprimitives:
nprimitives = shape[0]
nsamples = shape[1]
else:
nsamples = self.size // nprimitives
# register the bounds
if nsamples <= 1:
self.bounds = [0, self.size]
else:
self.bounds = np.arange(0, self.size + 1, nsamples)
# automatic color with color map
if autocolor is not None:
if nprimitives <= 1:
color = get_next_color(autocolor)
else:
color = np.array([get_next_color(i + autocolor) for i in xrange(nprimitives)])
# set position attribute
self.add_attribute("position0", ndim=2, data=position, autonormalizable=True)
index = np.array(index)
self.add_index("index", data=index)
if color_array_index is None:
color_array_index = np.repeat(np.arange(nprimitives), nsamples)
color_array_index = np.array(color_array_index)
ncolors = color.shape[0]
ncomponents = color.shape[1]
color = color.reshape((1, ncolors, ncomponents))
dx = 1. / ncolors
offset = dx / 2.
self.add_texture('colormap', ncomponents=ncomponents, ndim=1, data=color)
self.add_attribute('index', ndim=1, vartype='int', data=color_array_index)
self.add_varying('vindex', vartype='int', ndim=1)
self.add_uniform('nchannels', vartype='float', ndim=1, data=float(nprimitives))
self.add_uniform('channel_height', vartype='float', ndim=1, data=channel_height)
self.add_vertex_main("""
vec2 position = position0;
position.y = channel_height * position.y + .9 * (2 * index - (nchannels - 1)) / (nchannels - 1);
vindex = index;
""")
self.add_fragment_main("""
float coord = %.5f + vindex * %.5f;
vec4 color = texture1D(colormap, coord);
out_color = color;
""" % (offset, dx))
# add point size uniform (when it's not specified, there might be some
# bugs where its value is obtained from other datasets...)
self.add_uniform("point_size", data=point_size)
self.add_vertex_main("""gl_PointSize = point_size;""")
