INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Flush GL commands This is a wrapper for glFlush (). This also flushes the GLIR command queue. | def flush(self):
"""Flush GL commands
This is a wrapper for glFlush(). This also flushes the GLIR
command queue.
"""
if hasattr(self, 'flush_commands'):
context = self
else:
context = get_current_canvas().context
context.glir.command('... |
Set OpenGL drawing hint Parameters ---------- target: str The target e. g. fog_hint line_smooth_hint point_smooth_hint. mode: str The mode to set ( e. g. fastest nicest dont_care ). | def set_hint(self, target, mode):
"""Set OpenGL drawing hint
Parameters
----------
target : str
The target, e.g. 'fog_hint', 'line_smooth_hint',
'point_smooth_hint'.
mode : str
The mode to set (e.g., 'fastest', 'nicest', 'dont_care').
... |
The GLIR queue corresponding to the current canvas | def glir(self):
""" The GLIR queue corresponding to the current canvas
"""
canvas = get_current_canvas()
if canvas is None:
msg = ("If you want to use gloo without vispy.app, " +
"use a gloo.context.FakeCanvas.")
raise RuntimeError('Gloo requir... |
Let Vispy use the target OpenGL ES 2. 0 implementation Also see vispy. use (). Parameters ---------- target: str The target GL backend to use. | def use_gl(target='gl2'):
""" Let Vispy use the target OpenGL ES 2.0 implementation
Also see ``vispy.use()``.
Parameters
----------
target : str
The target GL backend to use.
Available backends:
* gl2 - Use ES 2.0 subset of desktop (i.e. normal) OpenGL
* gl+ - Use the ... |
Clear names that are not part of the strict ES API | def _clear_namespace():
""" Clear names that are not part of the strict ES API
"""
ok_names = set(default_backend.__dict__)
ok_names.update(['gl2', 'glplus']) # don't remove the module
NS = globals()
for name in list(NS.keys()):
if name.lower().startswith('gl'):
if name not ... |
Inject all objects that start with gl from the source into the dest. source and dest can be dicts modules or BaseGLProxy s. | def _copy_gl_functions(source, dest, constants=False):
""" Inject all objects that start with 'gl' from the source
into the dest. source and dest can be dicts, modules or BaseGLProxy's.
"""
# Get dicts
if isinstance(source, BaseGLProxy):
s = {}
for key in dir(source):
s[k... |
Check this from time to time to detect GL errors. | def check_error(when='periodic check'):
""" Check this from time to time to detect GL errors.
Parameters
----------
when : str
Shown in the exception to help the developer determine when
this check was done.
"""
errors = []
while True:
err = glGetError()
if ... |
Get a useful ( and not too large ) represetation of an argument. | def _arg_repr(self, arg):
""" Get a useful (and not too large) represetation of an argument.
"""
r = repr(arg)
max = 40
if len(r) > max:
if hasattr(arg, 'shape'):
r = 'array:' + 'x'.join([repr(s) for s in arg.shape])
else:
r... |
Set the scalar array data | def set_data(self, data):
""" Set the scalar array data
Parameters
----------
data : ndarray
A 2D array of scalar values. The isocurve is constructed to show
all locations in the scalar field equal to ``self.levels``.
"""
self._data = data
... |
retrieve vertices and connects from given paths - list | def _get_verts_and_connect(self, paths):
""" retrieve vertices and connects from given paths-list
"""
verts = np.vstack(paths)
gaps = np.add.accumulate(np.array([len(x) for x in paths])) - 1
connect = np.ones(gaps[-1], dtype=bool)
connect[gaps[:-1]] = False
return... |
compute LineVisual vertices connects and color - index | def _compute_iso_line(self):
""" compute LineVisual vertices, connects and color-index
"""
level_index = []
connects = []
verts = []
# calculate which level are within data range
# this works for now and the existing examples, but should be tested
# thoro... |
Connect this emitter to a new callback. | def connect(self, callback, ref=False, position='first',
before=None, after=None):
"""Connect this emitter to a new callback.
Parameters
----------
callback : function | tuple
*callback* may be either a callable object or a tuple
(object, attr_nam... |
Disconnect a callback from this emitter. | def disconnect(self, callback=None):
"""Disconnect a callback from this emitter.
If no callback is specified, then *all* callbacks are removed.
If the callback was not already connected, then the call does nothing.
"""
if callback is None:
self._callbacks = []
... |
Block this emitter. Any attempts to emit an event while blocked will be silently ignored. If * callback * is given then the emitter is only blocked for that specific callback. | def block(self, callback=None):
"""Block this emitter. Any attempts to emit an event while blocked
will be silently ignored. If *callback* is given, then the emitter
is only blocked for that specific callback.
Calls to block are cumulative; the emitter must be unblocked the same
... |
Unblock this emitter. See: func: event. EventEmitter. block. Note: Use of unblock ( None ) only reverses the effect of block ( None ) ; it does not unblock callbacks that were explicitly blocked using block ( callback ). | def unblock(self, callback=None):
""" Unblock this emitter. See :func:`event.EventEmitter.block`.
Note: Use of ``unblock(None)`` only reverses the effect of
``block(None)``; it does not unblock callbacks that were explicitly
blocked using ``block(callback)``.
"""
... |
Add one or more EventEmitter instances to this emitter group. Each keyword argument may be specified as either an EventEmitter instance or an Event subclass in which case an EventEmitter will be generated automatically:: | def add(self, auto_connect=None, **kwargs):
""" Add one or more EventEmitter instances to this emitter group.
Each keyword argument may be specified as either an EventEmitter
instance or an Event subclass, in which case an EventEmitter will be
generated automatically::
# Thi... |
Block all emitters in this group. | def block_all(self):
""" Block all emitters in this group.
"""
self.block()
for em in self._emitters.values():
em.block() |
Unblock all emitters in this group. | def unblock_all(self):
""" Unblock all emitters in this group.
"""
self.unblock()
for em in self._emitters.values():
em.unblock() |
Connect the callback to the event group. The callback will receive events from * all * of the emitters in the group. | def connect(self, callback, ref=False, position='first',
before=None, after=None):
""" Connect the callback to the event group. The callback will receive
events from *all* of the emitters in the group.
See :func:`EventEmitter.connect() <vispy.event.EventEmitter.connect>`
... |
Disconnect the callback from this group. See: func: connect () <vispy. event. EmitterGroup. connect > and: func: EventEmitter. connect () <vispy. event. EventEmitter. connect > for more information. | def disconnect(self, callback=None):
""" Disconnect the callback from this group. See
:func:`connect() <vispy.event.EmitterGroup.connect>` and
:func:`EventEmitter.connect() <vispy.event.EventEmitter.connect>` for
more information.
"""
ret = EventEmitter.disconnect(self, c... |
TODO add handling for bad input | def validate_input_format(utterance, intent):
""" TODO add handling for bad input"""
slots = {slot["name"] for slot in intent["slots"]}
split_utt = re.split("{(.*)}", utterance)
banned = set("-/\\()^%$#@~`-_=+><;:") # Banned characters
for token in split_utt:
if (banned & set(token)):
... |
Generate isosurface from volumetric data using marching cubes algorithm. See Paul Bourke Polygonising a Scalar Field ( http:// paulbourke. net/ geometry/ polygonise/ ) * data * 3D numpy array of scalar values * level * The level at which to generate an isosurface Returns an array of vertex coordinates ( Nv 3 ) and an a... | def isosurface(data, level):
"""
Generate isosurface from volumetric data using marching cubes algorithm.
See Paul Bourke, "Polygonising a Scalar Field"
(http://paulbourke.net/geometry/polygonise/)
*data* 3D numpy array of scalar values
*level* The level at which to generate an isosurf... |
Extract all data buffers from the list of GLIR commands and replace them by buffer pointers { buffer: <buffer_index > }. Return the modified list # of GILR commands and the list of buffers as well. | def _extract_buffers(commands):
"""Extract all data buffers from the list of GLIR commands, and replace
them by buffer pointers {buffer: <buffer_index>}. Return the modified list
# of GILR commands and the list of buffers as well."""
# First, filter all DATA commands.
data_commands = [command for co... |
Internal function: serialize native types. | def _serialize_item(item):
"""Internal function: serialize native types."""
# Recursively serialize lists, tuples, and dicts.
if isinstance(item, (list, tuple)):
return [_serialize_item(subitem) for subitem in item]
elif isinstance(item, dict):
return dict([(key, _serialize_item(value))
... |
Create a JSON - serializable message of GLIR commands. NumPy arrays are serialized according to the specified method. | def create_glir_message(commands, array_serialization=None):
"""Create a JSON-serializable message of GLIR commands. NumPy arrays
are serialized according to the specified method.
Arguments
---------
commands : list
List of GLIR commands.
array_serialization : string or None
Se... |
Start Session | def start_session(self):
""" Start Session """
response = self.request("hello")
bits = response.split(" ")
self.server_info.update({
"server_version": bits[2],
"protocol_version": bits[4],
"screen_width": int(bits[7]),
"screen_height": int... |
Request | def request(self, command_string):
""" Request """
self.send(command_string)
if self.debug:
print("Telnet Request: %s" % (command_string))
while True:
response = urllib.parse.unquote(self.tn.read_until(b"\n").decode())
if "success" in response: # N... |
Add Screen | def add_screen(self, ref):
""" Add Screen """
if ref not in self.screens:
screen = Screen(self, ref)
screen.clear() # TODO Check this is needed, new screens should be clear.
self.screens[ref] = screen
return self.screens[ref] |
Add a key. | def add_key(self, ref, mode="shared"):
"""
Add a key.
(ref)
Return key name or None on error
"""
if ref not in self.keys:
response = self.request("client_add_key %s -%s" % (ref, mode))
if "success" not in response:
return None
... |
Delete a key. | def del_key(self, ref):
"""
Delete a key.
(ref)
Return None or LCDd response on error
"""
if ref not in self.keys:
response = self.request("client_del_key %s" % (ref))
self.keys.remove(ref)
if "success" in response:
ret... |
launch browser and virtual display first of all to be launched | def launch(self):
"""launch browser and virtual display, first of all to be launched"""
try:
# init virtual Display
self.vbro = Display()
self.vbro.start()
logger.debug("virtual display launched")
except Exception:
raise exceptions.VBro... |
css find function abbreviation | def css(self, css_path, dom=None):
"""css find function abbreviation"""
if dom is None:
dom = self.browser
return expect(dom.find_by_css, args=[css_path]) |
return the first value of self. css | def css1(self, css_path, dom=None):
"""return the first value of self.css"""
if dom is None:
dom = self.browser
def _css1(path, domm):
"""virtual local func"""
return self.css(path, domm)[0]
return expect(_css1, args=[css_path, dom]) |
name find function abbreviation | def search_name(self, name, dom=None):
"""name find function abbreviation"""
if dom is None:
dom = self.browser
return expect(dom.find_by_name, args=[name]) |
xpath find function abbreviation | def xpath(self, xpath, dom=None):
"""xpath find function abbreviation"""
if dom is None:
dom = self.browser
return expect(dom.find_by_xpath, args=[xpath]) |
check if element is present by css | def elCss(self, css_path, dom=None):
"""check if element is present by css"""
if dom is None:
dom = self.browser
return expect(dom.is_element_present_by_css, args=[css_path]) |
check if element is present by css | def elXpath(self, xpath, dom=None):
"""check if element is present by css"""
if dom is None:
dom = self.browser
return expect(dom.is_element_present_by_xpath, args=[xpath]) |
login function | def login(self, username, password, mode="demo"):
"""login function"""
url = "https://trading212.com/it/login"
try:
logger.debug(f"visiting %s" % url)
self.browser.visit(url)
logger.debug(f"connected to %s" % url)
except selenium.common.exceptions.WebD... |
logout func ( quit browser ) | def logout(self):
"""logout func (quit browser)"""
try:
self.browser.quit()
except Exception:
raise exceptions.BrowserException(self.brow_name, "not started")
return False
self.vbro.stop()
logger.info("logged out")
return True |
factory method pattern | def new_pos(self, html_div):
"""factory method pattern"""
pos = self.Position(self, html_div)
pos.bind_mov()
self.positions.append(pos)
return pos |
Convert a [ user [: pass ] @ ] host: port string to a Connection tuple. | def _make_hostport(conn, default_host, default_port, default_user='', default_password=None):
"""Convert a '[user[:pass]@]host:port' string to a Connection tuple.
If the given connection is empty, use defaults.
If no port is given, use the default.
Args:
conn (str): the string describing the t... |
Create and connect to the LCDd server. | def _make_lcdproc(
lcd_host, lcd_port, retry_config,
charset=DEFAULT_LCDPROC_CHARSET, lcdd_debug=False):
"""Create and connect to the LCDd server.
Args:
lcd_host (str): the hostname to connect to
lcd_prot (int): the port to connect to
charset (str): the charset to use wh... |
Create a ScreenPatternList from a given pattern text. | def _make_patterns(patterns):
"""Create a ScreenPatternList from a given pattern text.
Args:
pattern_txt (str list): the patterns
Returns:
mpdlcd.display_pattern.ScreenPatternList: a list of patterns from the
given entries.
"""
field_registry = display_fields.FieldRegis... |
Run the server. | def run_forever(
lcdproc='', mpd='', lcdproc_screen=DEFAULT_LCD_SCREEN_NAME,
lcdproc_charset=DEFAULT_LCDPROC_CHARSET,
lcdd_debug=False,
pattern='', patterns=[],
refresh=DEFAULT_REFRESH,
backlight_on=DEFAULT_BACKLIGHT_ON,
priority_playing=DEFAULT_PRIORITY,
... |
Read configuration from the given file. | def _read_config(filename):
"""Read configuration from the given file.
Parsing is performed through the configparser library.
Returns:
dict: a flattened dict of (option_name, value), using defaults.
"""
parser = configparser.RawConfigParser()
if filename and not parser.read(filename):
... |
Extract options values from a configparser optparse pair. | def _extract_options(config, options, *args):
"""Extract options values from a configparser, optparse pair.
Options given on command line take precedence over options read in the
configuration file.
Args:
config (dict): option values read from a config file through
configparser
... |
Set the render - buffer size and format | def resize(self, shape, format=None):
""" Set the render-buffer size and format
Parameters
----------
shape : tuple of integers
New shape in yx order. A render buffer is always 2D. For
symmetry with the texture class, a 3-element tuple can also
be giv... |
Activate/ use this frame buffer. | def activate(self):
""" Activate/use this frame buffer.
"""
# Send command
self._glir.command('FRAMEBUFFER', self._id, True)
# Associate canvas now
canvas = get_current_canvas()
if canvas is not None:
canvas.context.glir.associate(self.glir) |
The shape of the Texture/ RenderBuffer attached to this FrameBuffer | def shape(self):
""" The shape of the Texture/RenderBuffer attached to this FrameBuffer
"""
if self.color_buffer is not None:
return self.color_buffer.shape[:2] # in case its a texture
if self.depth_buffer is not None:
return self.depth_buffer.shape[:2]
i... |
Resize all attached buffers with the given shape | def resize(self, shape):
""" Resize all attached buffers with the given shape
Parameters
----------
shape : tuple of two integers
New buffer shape (h, w), to be applied to all currently
attached buffers. For buffers that are a texture, the number
of c... |
Return array of pixel values in an attached buffer Parameters ---------- mode: str The buffer type to read. May be color depth or stencil. alpha: bool If True returns RGBA array. Otherwise returns RGB. Returns ------- buffer: array 3D array of pixels in np. uint8 format. The array shape is ( h w 3 ) or ( h w 4 ) with t... | def read(self, mode='color', alpha=True):
""" Return array of pixel values in an attached buffer
Parameters
----------
mode : str
The buffer type to read. May be 'color', 'depth', or 'stencil'.
alpha : bool
If True, returns RGBA array. Otherwise, ... |
Set the data used to draw this visual. | def set_data(self, pos=None, color=None, width=None, connect=None):
""" Set the data used to draw this visual.
Parameters
----------
pos : array
Array of shape (..., 2) or (..., 3) specifying vertex coordinates.
color : Color, tuple, or array
The color to... |
Get the bounds | def _compute_bounds(self, axis, view):
"""Get the bounds
Parameters
----------
mode : str
Describes the type of boundary requested. Can be "visual", "data",
or "mouse".
axis : 0, 1, 2
The axis along which to measure the bounding values, in
... |
Bake a list of 2D vertices for rendering them as thick line. Each line segment must have its own vertices because of antialias ( this means no vertex sharing between two adjacent line segments ). | def _agg_bake(cls, vertices, color, closed=False):
"""
Bake a list of 2D vertices for rendering them as thick line. Each line
segment must have its own vertices because of antialias (this means no
vertex sharing between two adjacent line segments).
"""
n = len(vertices)
... |
This actually calculates the kerning + advance | def _get_k_p_a(font, left, right):
"""This actually calculates the kerning + advance"""
# http://lists.apple.com/archives/coretext-dev/2010/Dec/msg00020.html
# 1) set up a CTTypesetter
chars = left + right
args = [None, 1, cf.kCFTypeDictionaryKeyCallBacks,
cf.kCFTypeDictionaryValueCallBa... |
Update the mesh data. | def set_data(self, xs=None, ys=None, zs=None, colors=None):
'''Update the mesh data.
Parameters
----------
xs : ndarray | None
A 2d array of x coordinates for the vertices of the mesh.
ys : ndarray | None
A 2d array of y coordinates for the vertices of th... |
Convert numpy array to PNG byte array. | def _make_png(data, level=6):
"""Convert numpy array to PNG byte array.
Parameters
----------
data : numpy.ndarray
Data must be (H, W, 3 | 4) with dtype = np.ubyte (np.uint8)
level : int
https://docs.python.org/2/library/zlib.html#zlib.compress
An integer from 0 to 9 control... |
Read a PNG file to RGB8 or RGBA8 | def read_png(filename):
"""Read a PNG file to RGB8 or RGBA8
Unlike imread, this requires no external dependencies.
Parameters
----------
filename : str
File to read.
Returns
-------
data : array
Image data.
See also
--------
write_png, imread, imsave
"... |
Write a PNG file | def write_png(filename, data):
"""Write a PNG file
Unlike imsave, this requires no external dependencies.
Parameters
----------
filename : str
File to save to.
data : array
Image data.
See also
--------
read_png, imread, imsave
"""
data = np.asarray(data)
... |
Read image data from disk | def imread(filename, format=None):
"""Read image data from disk
Requires imageio or PIL.
Parameters
----------
filename : str
Filename to read.
format : str | None
Format of the file. If None, it will be inferred from the filename.
Returns
-------
data : array
... |
Save image data to disk | def imsave(filename, im, format=None):
"""Save image data to disk
Requires imageio or PIL.
Parameters
----------
filename : str
Filename to write.
im : array
Image data.
format : str | None
Format of the file. If None, it will be inferred from the filename.
See... |
Utility to search for imageio or PIL | def _check_img_lib():
"""Utility to search for imageio or PIL"""
# Import imageio or PIL
imageio = PIL = None
try:
import imageio
except ImportError:
try:
import PIL.Image
except ImportError:
pass
return imageio, PIL |
Helper function to prompt user for input of a specific type e. g. float str int Designed to work with both python 2 and 3 Yes I know this is ugly. | def read_from_user(input_type, *args, **kwargs):
'''
Helper function to prompt user for input of a specific type
e.g. float, str, int
Designed to work with both python 2 and 3
Yes I know this is ugly.
'''
def _read_in(*args, **kwargs):
while True:
try: tmp = raw_inpu... |
Helper function to load builtin slots from the data location | def load_builtin_slots():
'''
Helper function to load builtin slots from the data location
'''
builtin_slots = {}
for index, line in enumerate(open(BUILTIN_SLOTS_LOCATION)):
o = line.strip().split('\t')
builtin_slots[index] = {'name' : o[0],
'descript... |
Function decorator displaying the function execution time | def timer(logger=None, level=logging.INFO,
fmt="function %(function_name)s execution time: %(execution_time).3f",
*func_or_func_args, **timer_kwargs):
""" Function decorator displaying the function execution time
All kwargs are the arguments taken by the Timer class constructor.
"""
... |
Append a new set of vertices to the collection. | def append(self, points, indices, **kwargs):
"""
Append a new set of vertices to the collection.
For kwargs argument, n is the number of vertices (local) or the number
of item (shared)
Parameters
----------
points : np.array
Vertices composing the t... |
Convert a given matplotlib figure to vispy | def _mpl_to_vispy(fig):
"""Convert a given matplotlib figure to vispy
This function is experimental and subject to change!
Requires matplotlib and mplexporter.
Parameters
----------
fig : instance of matplotlib Figure
The populated figure to display.
Returns
-------
canvas... |
Show current figures using vispy | def show(block=False):
"""Show current figures using vispy
Parameters
----------
block : bool
If True, blocking mode will be used. If False, then non-blocking
/ interactive mode will be used.
Returns
-------
canvases : list
List of the vispy canvases that were creat... |
Helper to get the parent axes of a given mplobj | def _mpl_ax_to(self, mplobj, output='vb'):
"""Helper to get the parent axes of a given mplobj"""
for ax in self._axs.values():
if ax['ax'] is mplobj.axes:
return ax[output]
raise RuntimeError('Parent axes could not be found!') |
Place the graph nodes at random places. | def random(adjacency_mat, directed=False, random_state=None):
"""
Place the graph nodes at random places.
Parameters
----------
adjacency_mat : matrix or sparse
The graph adjacency matrix
directed : bool
Whether the graph is directed. If this is True, is will also
genera... |
Generate isocurve from 2D data using marching squares algorithm. | def isocurve(data, level, connected=False, extend_to_edge=False):
"""
Generate isocurve from 2D data using marching squares algorithm.
Parameters
----------
data : ndarray
2D numpy array of scalar values
level : float
The level at which to generate an isosurface
connected : ... |
The position of this event in the local coordinate system of the visual. | def pos(self):
""" The position of this event in the local coordinate system of the
visual.
"""
if self._pos is None:
tr = self.visual.get_transform('canvas', 'visual')
self._pos = tr.map(self.mouse_event.pos)
return self._pos |
The mouse event immediately prior to this one. This property is None when no mouse buttons are pressed. | def last_event(self):
""" The mouse event immediately prior to this one. This
property is None when no mouse buttons are pressed.
"""
if self.mouse_event.last_event is None:
return None
ev = self.copy()
ev.mouse_event = self.mouse_event.last_event
retu... |
The mouse press event that initiated a mouse drag if any. | def press_event(self):
""" The mouse press event that initiated a mouse drag, if any.
"""
if self.mouse_event.press_event is None:
return None
ev = self.copy()
ev.mouse_event = self.mouse_event.press_event
return ev |
Get lowercase string representation of enum. | def check_enum(enum, name=None, valid=None):
""" Get lowercase string representation of enum.
"""
name = name or 'enum'
# Try to convert
res = None
if isinstance(enum, int):
if hasattr(enum, 'name') and enum.name.startswith('GL_'):
res = enum.name[3:].lower()
elif isinsta... |
Draw a 2D texture to the current viewport | def draw_texture(tex):
"""Draw a 2D texture to the current viewport
Parameters
----------
tex : instance of Texture2D
The texture to draw.
"""
from .program import Program
program = Program(vert_draw, frag_draw)
program['u_texture'] = tex
program['a_position'] = [[-1., -1.],... |
Match pattern against the output of func passing the results as floats to func. If anything fails return None. | def _get_dpi_from(cmd, pattern, func):
"""Match pattern against the output of func, passing the results as
floats to func. If anything fails, return None.
"""
try:
out, _ = run_subprocess([cmd])
except (OSError, CalledProcessError):
pass
else:
match = re.search(pattern, ... |
Get screen DPI from the OS | def get_dpi(raise_error=True):
"""Get screen DPI from the OS
Parameters
----------
raise_error : bool
If True, raise an error if DPI could not be determined.
Returns
-------
dpi : float
Dots per inch of the primary screen.
"""
# If we are running without an X server... |
Set the data | def set_data(self, adjacency_mat=None, **kwargs):
"""Set the data
Parameters
----------
adjacency_mat : ndarray | None
The adjacency matrix.
**kwargs : dict
Keyword arguments to pass to the arrows.
"""
if adjacency_mat is not None:
... |
Calculate a size | def calc_size(rect, orientation):
"""Calculate a size
Parameters
----------
rect : rectangle
The rectangle.
orientation : str
Either "bottom" or "top".
"""
(total_halfx, total_halfy) = rect.center
if orientation in ["bottom", "top"... |
Try to reduce dtype up to a given level when it is possible | def dtype_reduce(dtype, level=0, depth=0):
"""
Try to reduce dtype up to a given level when it is possible
dtype = [ ('vertex', [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]),
('normal', [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]),
('color', [('r', 'f4'), ('g', 'f4'), ('b', 'f4'),... |
Generate the GLSL code needed to retrieve fake uniform values from a texture. | def fetchcode(utype, prefix=""):
"""
Generate the GLSL code needed to retrieve fake uniform values from a
texture.
uniforms : sampler2D
Texture to fetch uniforms from
uniforms_shape: vec3
Size of texture (width,height,count) where count is the number of float
to be fetched.... |
Generate vertices & indices for a filled and outlined cube | def create_cube():
""" Generate vertices & indices for a filled and outlined cube
Returns
-------
vertices : array
Array of vertices suitable for use as a VertexBuffer.
filled : array
Indices to use to produce a filled cube.
outline : array
Indices to use to produce an o... |
Generate vertices & indices for a filled and outlined plane. | def create_plane(width=1, height=1, width_segments=1, height_segments=1,
direction='+z'):
""" Generate vertices & indices for a filled and outlined plane.
Parameters
----------
width : float
Plane width.
height : float
Plane height.
width_segments : int
... |
Generate vertices & indices for a filled and outlined box. | def create_box(width=1, height=1, depth=1, width_segments=1, height_segments=1,
depth_segments=1, planes=None):
""" Generate vertices & indices for a filled and outlined box.
Parameters
----------
width : float
Box width.
height : float
Box height.
depth : float
... |
Create a sphere | def create_sphere(rows=10, cols=10, depth=10, radius=1.0, offset=True,
subdivisions=3, method='latitude'):
"""Create a sphere
Parameters
----------
rows : int
Number of rows (for method='latitude' and 'cube').
cols : int
Number of columns (for method='latitude' and... |
Create a cylinder | def create_cylinder(rows, cols, radius=[1.0, 1.0], length=1.0, offset=False):
"""Create a cylinder
Parameters
----------
rows : int
Number of rows.
cols : int
Number of columns.
radius : tuple of float
Cylinder radii.
length : float
Length of the cylinder.
... |
Create a cone | def create_cone(cols, radius=1.0, length=1.0):
"""Create a cone
Parameters
----------
cols : int
Number of faces.
radius : float
Base cone radius.
length : float
Length of the cone.
Returns
-------
cone : MeshData
Vertices and faces computed for a co... |
Create a 3D arrow using a cylinder plus cone | def create_arrow(rows, cols, radius=0.1, length=1.0,
cone_radius=None, cone_length=None):
"""Create a 3D arrow using a cylinder plus cone
Parameters
----------
rows : int
Number of rows.
cols : int
Number of columns.
radius : float
Base cylinder radius.
... |
Generate vertices and indices for an implicitly connected mesh. | def create_grid_mesh(xs, ys, zs):
'''Generate vertices and indices for an implicitly connected mesh.
The intention is that this makes it simple to generate a mesh
from meshgrid data.
Parameters
----------
xs : ndarray
A 2d array of x coordinates for the vertices of the mesh. Must
... |
Generate the vertices for straight lines between nodes. | def _straight_line_vertices(adjacency_mat, node_coords, directed=False):
"""
Generate the vertices for straight lines between nodes.
If it is a directed graph, it also generates the vertices which can be
passed to an :class:`ArrowVisual`.
Parameters
----------
adjacency_mat : array
... |
Normalize the given coordinate list to the range [ 0 scale ]. | def _rescale_layout(pos, scale=1):
"""
Normalize the given coordinate list to the range [0, `scale`].
Parameters
----------
pos : array
Coordinate list
scale : number
The upperbound value for the coordinates range
Returns
-------
pos : array
The rescaled (no... |
Get unique FT_Library handle | def get_handle():
'''
Get unique FT_Library handle
'''
global __handle__
if not __handle__:
__handle__ = FT_Library()
error = FT_Init_FreeType(byref(__handle__))
if error:
raise RuntimeError(hex(error))
return __handle__ |
Return the version of the FreeType library being used as a tuple of ( major version number minor version number patch version number ) | def version():
'''
Return the version of the FreeType library being used as a tuple of
( major version number, minor version number, patch version number )
'''
amajor = FT_Int()
aminor = FT_Int()
apatch = FT_Int()
library = get_handle()
FT_Library_Version(library, byref(amajor), byre... |
Factory function for creating new cameras using a string name. | def make_camera(cam_type, *args, **kwargs):
""" Factory function for creating new cameras using a string name.
Parameters
----------
cam_type : str
May be one of:
* 'panzoom' : Creates :class:`PanZoomCamera`
* 'turntable' : Creates :class:`TurntableCamera`
*... |
Set the position of the datapoints | def set_data_values(self, label, x, y, z):
"""
Set the position of the datapoints
"""
# TODO: avoid re-allocating an array every time
self.layers[label]['data'] = np.array([x, y, z]).transpose()
self._update() |
mode: string - raw ( speed: fastest size: small output: ugly no dash no thickness ) - agg ( speed: slower size: medium output: perfect no dash ) | def SegmentCollection(mode="agg-fast", *args, **kwargs):
"""
mode: string
- "raw" (speed: fastest, size: small, output: ugly, no dash,
no thickness)
- "agg" (speed: slower, size: medium, output: perfect, no dash)
"""
if mode == "raw":
return RawSegmentCollection(*args... |
Computes the parameterization of a parametric surface | def surface(func, umin=0, umax=2 * np.pi, ucount=64, urepeat=1.0,
vmin=0, vmax=2 * np.pi, vcount=64, vrepeat=1.0):
"""
Computes the parameterization of a parametric surface
func: function(u,v)
Parametric function used to build the surface
"""
vtype = [('position', np.float32, 3... |
mode: string - raw ( speed: fastest size: small output: ugly ) - agg ( speed: fast size: small output: beautiful ) | def PointCollection(mode="raw", *args, **kwargs):
"""
mode: string
- "raw" (speed: fastest, size: small, output: ugly)
- "agg" (speed: fast, size: small, output: beautiful)
"""
if mode == "raw":
return RawPointCollection(*args, **kwargs)
return AggPointCollection(*args,... |
Append new data to the right side of every line strip and remove as much data from the left. Parameters ---------- data: array - like A data array to append. | def roll_data(self, data):
"""Append new data to the right side of every line strip and remove
as much data from the left.
Parameters
----------
data : array-like
A data array to append.
"""
data = data.astype('float32')[..., np.newaxis]
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.