text_prompt stringlengths 157 13.1k | code_prompt stringlengths 7 19.8k ⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_gl_configuration():
"""Read the current gl configuration This function uses constants that are not in the OpenGL ES 2.1 namespace, so only use this on desktop systems. Returns ------- config : dict The currently active OpenGL configuration. """ |
# XXX eventually maybe we can ask `gl` whether or not we can access these
gl.check_error('pre-config check')
config = dict()
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0)
fb_param = gl.glGetFramebufferAttachmentParameter
# copied since they aren't in ES:
GL_FRONT_LEFT = 1024
GL_DEPTH = 6145
GL_STENCIL = 6146
GL_SRGB = 35904
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 33296
GL_STEREO = 3123
GL_DOUBLEBUFFER = 3122
sizes = dict(red=(GL_FRONT_LEFT, 33298),
green=(GL_FRONT_LEFT, 33299),
blue=(GL_FRONT_LEFT, 33300),
alpha=(GL_FRONT_LEFT, 33301),
depth=(GL_DEPTH, 33302),
stencil=(GL_STENCIL, 33303))
for key, val in sizes.items():
config[key + '_size'] = fb_param(gl.GL_FRAMEBUFFER, val[0], val[1])
val = fb_param(gl.GL_FRAMEBUFFER, GL_FRONT_LEFT,
GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)
if val not in (gl.GL_LINEAR, GL_SRGB):
raise RuntimeError('unknown value for SRGB: %s' % val)
config['srgb'] = True if val == GL_SRGB else False # GL_LINEAR
config['stereo'] = True if gl.glGetParameter(GL_STEREO) else False
config['double_buffer'] = (True if gl.glGetParameter(GL_DOUBLEBUFFER)
else False)
config['samples'] = gl.glGetParameter(gl.GL_SAMPLES)
gl.check_error('post-config check')
return config |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_clear_color(self, color='black', alpha=None):
"""Set the screen clear color This is a wrapper for gl.glClearColor. Parameters color : str | tuple | instance of Color Color to use. See vispy.color.Color for options. alpha : float | None Alpha to use. """ |
self.glir.command('FUNC', 'glClearColor', *Color(color, alpha).rgba) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 requires a Canvas to run.\n' + msg)
return canvas.context.glir |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 in ok_names:
del NS[name] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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[key] = getattr(source, key)
source = s
elif not isinstance(source, dict):
source = source.__dict__
if not isinstance(dest, dict):
dest = dest.__dict__
# Copy names
funcnames = [name for name in source.keys() if name.startswith('gl')]
for name in funcnames:
dest[name] = source[name]
# Copy constants
if constants:
constnames = [name for name in source.keys() if name.startswith('GL_')]
for name in constnames:
dest[name] = source[name] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 err == GL_NO_ERROR or (errors and err == errors[-1]):
break
errors.append(err)
if errors:
msg = ', '.join([repr(ENUM_MAP.get(e, e)) for e in errors])
err = RuntimeError('OpenGL got errors (%s): %s' % (when, msg))
err.errors = errors
err.err = errors[-1] # pyopengl compat
raise err |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 verts, connect |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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
# thoroughly also with the data-sanity check in set_data-function
choice = np.nonzero((self.levels > self._data.min()) &
(self._levels < self._data.max()))
levels_to_calc = np.array(self.levels)[choice]
# save minimum level index
self._level_min = choice[0][0]
for level in levels_to_calc:
# if we use matplotlib isoline algorithm we need to add half a
# pixel in both (x,y) dimensions because isolines are aligned to
# pixel centers
if _HAS_MPL:
nlist = self._iso.trace(level, level, 0)
paths = nlist[:len(nlist)//2]
v, c = self._get_verts_and_connect(paths)
v += np.array([0.5, 0.5])
else:
paths = isocurve(self._data.astype(float).T, level,
extend_to_edge=True, connected=True)
v, c = self._get_verts_and_connect(paths)
level_index.append(v.shape[0])
connects.append(np.hstack((c, [False])))
verts.append(v)
self._li = np.hstack(level_index)
self._connect = np.hstack(connects)
self._verts = np.vstack(verts) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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_name) where object.attr_name will point to a callable object. Note that only a weak reference to ``object`` will be kept. ref : bool | str Reference used to identify the callback in ``before``/``after``. If True, the callback ref will automatically determined (see Notes). If False, the callback cannot be referred to by a string. If str, the given string will be used. Note that if ``ref`` is not unique in ``callback_refs``, an error will be thrown. position : str If ``'first'``, the first eligible position is used (that meets the before and after criteria), ``'last'`` will use the last position. before : str | callback | list of str or callback | None List of callbacks that the current callback should precede. Can be None if no before-criteria should be used. after : str | callback | list of str or callback | None List of callbacks that the current callback should follow. Can be None if no after-criteria should be used. Notes ----- If ``ref=True``, the callback reference will be determined from: 1. If ``callback`` is ``tuple``, the secend element in the tuple. 2. The ``__name__`` attribute. 3. The ``__class__.__name__`` attribute. The current list of callback refs can be obtained using ``event.callback_refs``. Callbacks can be referred to by either their string reference (if given), or by the actual callback that was attached (e.g., ``(canvas, 'swap_buffers')``). If the specified callback is already connected, then the request is ignored. If before is None and after is None (default), the new callback will be added to the beginning of the callback list. Thus the callback that is connected _last_ will be the _first_ to receive events from the emitter. """ |
callbacks = self.callbacks
callback_refs = self.callback_refs
callback = self._normalize_cb(callback)
if callback in callbacks:
return
# deal with the ref
if isinstance(ref, bool):
if ref:
if isinstance(callback, tuple):
ref = callback[1]
elif hasattr(callback, '__name__'): # function
ref = callback.__name__
else: # Method, or other
ref = callback.__class__.__name__
else:
ref = None
elif not isinstance(ref, string_types):
raise TypeError('ref must be a bool or string')
if ref is not None and ref in self._callback_refs:
raise ValueError('ref "%s" is not unique' % ref)
# positions
if position not in ('first', 'last'):
raise ValueError('position must be "first" or "last", not %s'
% position)
# bounds
bounds = list() # upper & lower bnds (inclusive) of possible cb locs
for ri, criteria in enumerate((before, after)):
if criteria is None or criteria == []:
bounds.append(len(callback_refs) if ri == 0 else 0)
else:
if not isinstance(criteria, list):
criteria = [criteria]
for c in criteria:
count = sum([(c == cn or c == cc) for cn, cc
in zip(callback_refs, callbacks)])
if count != 1:
raise ValueError('criteria "%s" is in the current '
'callback list %s times:\n%s\n%s'
% (criteria, count,
callback_refs, callbacks))
matches = [ci for ci, (cn, cc) in enumerate(zip(callback_refs,
callbacks))
if (cc in criteria or cn in criteria)]
bounds.append(matches[0] if ri == 0 else (matches[-1] + 1))
if bounds[0] < bounds[1]: # i.e., "place before" < "place after"
raise RuntimeError('cannot place callback before "%s" '
'and after "%s" for callbacks: %s'
% (before, after, callback_refs))
idx = bounds[1] if position == 'first' else bounds[0] # 'last'
# actually add the callback
self._callbacks.insert(idx, callback)
self._callback_refs.insert(idx, ref)
return callback |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 = []
self._callback_refs = []
else:
callback = self._normalize_cb(callback)
if callback in self._callbacks:
idx = self._callbacks.index(callback)
self._callbacks.pop(idx)
self._callback_refs.pop(idx) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def block_all(self):
""" Block all emitters in this group. """ |
self.block()
for em in self._emitters.values():
em.block() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def unblock_all(self):
""" Unblock all emitters in this group. """ |
self.unblock()
for em in self._emitters.values():
em.unblock() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 Serialization method for NumPy arrays. Possible values are: 'binary' (default) : use a binary string 'base64' : base64 encoded string of the array """ |
# Default serialization method for NumPy arrays.
if array_serialization is None:
array_serialization = 'binary'
# Extract the buffers.
commands_modified, buffers = _extract_buffers(commands)
# Serialize the modified commands (with buffer pointers) and the buffers.
commands_serialized = [_serialize_command(command_modified)
for command_modified in commands_modified]
buffers_serialized = [_serialize_buffer(buffer, array_serialization)
for buffer in buffers]
# Create the final message.
msg = {
'msg_type': 'glir_commands',
'commands': commands_serialized,
'buffers': buffers_serialized,
}
return msg |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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
self.keys.append(ref)
return ref |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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.VBroException()
try:
self.browser = Browser(self.brow_name)
logger.debug(f"browser {self.brow_name} launched")
except Exception:
raise exceptions.BrowserException(
self.brow_name, "failed to launch")
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def new_pos(self, html_div):
"""factory method pattern""" |
pos = self.Position(self, html_div)
pos.bind_mov()
self.positions.append(pos)
return pos |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 when sending messages to lcdproc lcdd_debug (bool):
whether to enable full LCDd debug retry_attempts (int):
the number of connection attempts retry_wait (int):
the time to wait between connection attempts retry_backoff (int):
the backoff for increasing inter-attempt delay Returns: lcdproc.server.Server """ |
class ServerSpawner(utils.AutoRetryCandidate):
"""Spawn the server, using auto-retry."""
@utils.auto_retry
def connect(self):
return lcdrunner.LcdProcServer(
lcd_host, lcd_port, charset=charset, debug=lcdd_debug)
spawner = ServerSpawner(retry_config=retry_config, logger=logger)
try:
return spawner.connect()
except socket.error as e:
logger.error('Unable to connect to lcdproc %s:%s : %r', lcd_host, lcd_port, e)
raise SystemExit(1) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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.FieldRegistry()
pattern_list = display_pattern.ScreenPatternList(
field_registry=field_registry,
)
for pattern in patterns:
pattern_list.add(pattern.split('\n'))
return pattern_list |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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):
sys.stderr.write("Unable to open configuration file %s. Use --config='' to disable this warning.\n" % filename)
config = {}
for section, defaults in BASE_CONFIG.items():
# Patterns are handled separately
if section == 'patterns':
continue
for name, descr in defaults.items():
kind, default = descr
if section in parser.sections() and name in parser.options(section):
if kind == 'int':
value = parser.getint(section, name)
elif kind == 'float':
value = parser.getfloat(section, name)
elif kind == 'bool':
value = parser.getboolean(section, name)
else:
value = parser.get(section, name)
else:
value = default
config[name] = value
if 'patterns' in parser.sections():
patterns = [parser.get('patterns', opt) for opt in parser.options('patterns')]
else:
patterns = DEFAULT_PATTERNS
config['patterns'] = patterns
return config |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 options (optparse.Options):
optparse 'options' object containing options values from the command line *args (str tuple):
name of the options to extract """ |
extract = {}
for key in args:
if key not in args:
continue
extract[key] = config[key]
option = getattr(options, key, None)
if option is not None:
extract[key] = option
return extract |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 given, in which case the last dimension is ignored. format : {None, 'color', 'depth', 'stencil'} The buffer format. If None, the current format is maintained. If that is also None, the format will be set upon attaching it to a framebuffer. One can also specify the explicit enum: GL_RGB565, GL_RGBA4, GL_RGB5_A1, GL_DEPTH_COMPONENT16, or GL_STENCIL_INDEX8 """ |
if not self._resizeable:
raise RuntimeError("RenderBuffer is not resizeable")
# Check shape
if not (isinstance(shape, tuple) and len(shape) in (2, 3)):
raise ValueError('RenderBuffer shape must be a 2/3 element tuple')
# Check format
if format is None:
format = self._format # Use current format (may be None)
elif isinstance(format, int):
pass # Do not check, maybe user needs desktop GL formats
elif isinstance(format, string_types):
if format not in ('color', 'depth', 'stencil'):
raise ValueError('RenderBuffer format must be "color", "depth"'
' or "stencil", not %r' % format)
else:
raise ValueError('Invalid RenderBuffer format: %r' % format)
# Store and send GLIR command
self._shape = tuple(shape[:2])
self._format = format
if self._format is not None:
self._glir.command('SIZE', self._id, self._shape, self._format) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 color channels is preserved. """ |
# Check
if not (isinstance(shape, tuple) and len(shape) == 2):
raise ValueError('RenderBuffer shape must be a 2-element tuple')
# Resize our buffers
for buf in (self.color_buffer, self.depth_buffer, self.stencil_buffer):
if buf is None:
continue
shape_ = shape
if isinstance(buf, Texture2D):
shape_ = shape + (self.color_buffer.shape[-1], )
buf.resize(shape_, buf.format) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_data(self, pos=None, color=None, width=None, connect=None):
""" Set the data used to draw this visual. Parameters pos : array color : Color, tuple, or array The color to use when drawing the line. If an array is given, it width: The width of the line in px. Line widths < 1 px will be rounded up to 1 px when using the 'gl' method. connect : str or array Determines which vertices are connected by lines. * "strip" causes the line to be drawn with each vertex connected to the next. * "segments" causes each pair of vertices to draw an independent line segment * int numpy arrays specify the exact set of segment pairs to connect. * bool numpy arrays specify which _adjacent_ pairs to connect. """ |
if pos is not None:
self._bounds = None
self._pos = pos
self._changed['pos'] = True
if color is not None:
self._color = color
self._changed['color'] = True
if width is not None:
self._width = width
self._changed['width'] = True
if connect is not None:
self._connect = connect
self._changed['connect'] = True
self.update() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 x-y-z order. """ |
# Can and should we calculate bounds?
if (self._bounds is None) and self._pos is not None:
pos = self._pos
self._bounds = [(pos[:, d].min(), pos[:, d].max())
for d in range(pos.shape[1])]
# Return what we can
if self._bounds is None:
return
else:
if axis < len(self._bounds):
return self._bounds[axis]
else:
return (0, 0) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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.kCFTypeDictionaryValueCallBacks]
attributes = cf.CFDictionaryCreateMutable(*args)
cf.CFDictionaryAddValue(attributes, kCTFontAttributeName, font)
string = cf.CFAttributedStringCreate(None, CFSTR(chars), attributes)
typesetter = ct.CTTypesetterCreateWithAttributedString(string)
cf.CFRelease(string)
cf.CFRelease(attributes)
# 2) extract a CTLine from it
range = CFRange(0, 1)
line = ct.CTTypesetterCreateLine(typesetter, range)
# 3) use CTLineGetOffsetForStringIndex to get the character positions
offset = ct.CTLineGetOffsetForStringIndex(line, 1, None)
cf.CFRelease(line)
cf.CFRelease(typesetter)
return offset |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| 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 the mesh.
zs : ndarray | None
A 2d array of z coordinates for the vertices of the mesh.
colors : ndarray | None
The color at each point of the mesh. Must have shape
(width, height, 4) or (width, height, 3) for rgba or rgb
color definitions respectively.
'''
if xs is None:
xs = self._xs
self.__vertices = None
if ys is None:
ys = self._ys
self.__vertices = None
if zs is None:
zs = self._zs
self.__vertices = None
if self.__vertices is None:
vertices, indices = create_grid_mesh(xs, ys, zs)
self._xs = xs
self._ys = ys
self._zs = zs
if self.__vertices is None:
vertices, indices = create_grid_mesh(self._xs, self._ys, self._zs)
self.__meshdata.set_vertices(vertices)
self.__meshdata.set_faces(indices)
if colors is not None:
self.__meshdata.set_vertex_colors(colors.reshape(
colors.shape[0] * colors.shape[1], colors.shape[2]))
MeshVisual.set_data(self, meshdata=self.__meshdata) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 controlling the level of compression: * 1 is fastest and produces the least compression, * 9 is slowest and produces the most. * 0 is no compression. The default value is 6. Returns ------- png : array PNG formatted array """ |
# Eventually we might want to use ext/png.py for this, but this
# routine *should* be faster b/c it's speacialized for our use case
def mkchunk(data, name):
if isinstance(data, np.ndarray):
size = data.nbytes
else:
size = len(data)
chunk = np.empty(size + 12, dtype=np.ubyte)
chunk.data[0:4] = np.array(size, '>u4').tostring()
chunk.data[4:8] = name.encode('ASCII')
chunk.data[8:8 + size] = data
# and-ing may not be necessary, but is done for safety:
# https://docs.python.org/3/library/zlib.html#zlib.crc32
chunk.data[-4:] = np.array(zlib.crc32(chunk[4:-4]) & 0xffffffff,
'>u4').tostring()
return chunk
if data.dtype != np.ubyte:
raise TypeError('data.dtype must be np.ubyte (np.uint8)')
dim = data.shape[2] # Dimension
if dim not in (3, 4):
raise TypeError('data.shape[2] must be in (3, 4)')
# www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IHDR
if dim == 4:
ctyp = 0b0110 # RGBA
else:
ctyp = 0b0010 # RGB
# www.libpng.org/pub/png/spec/1.2/PNG-Structure.html
header = b'\x89PNG\x0d\x0a\x1a\x0a' # header
h, w = data.shape[:2]
depth = data.itemsize * 8
ihdr = struct.pack('!IIBBBBB', w, h, depth, ctyp, 0, 0, 0)
c1 = mkchunk(ihdr, 'IHDR')
# www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IDAT
# insert filter byte at each scanline
idat = np.empty((h, w * dim + 1), dtype=np.ubyte)
idat[:, 1:] = data.reshape(h, w * dim)
idat[:, 0] = 0
comp_data = zlib.compress(idat, level)
c2 = mkchunk(comp_data, 'IDAT')
c3 = mkchunk(np.empty((0,), dtype=np.ubyte), 'IEND')
# concatenate
lh = len(header)
png = np.empty(lh + c1.nbytes + c2.nbytes + c3.nbytes, dtype=np.ubyte)
png.data[:lh] = header
p = lh
for chunk in (c1, c2, c3):
png[p:p + len(chunk)] = chunk
p += chunk.nbytes
return png |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 """ |
x = Reader(filename)
try:
alpha = x.asDirect()[3]['alpha']
if alpha:
y = x.asRGBA8()[2]
n = 4
else:
y = x.asRGB8()[2]
n = 3
y = np.array([yy for yy in y], np.uint8)
finally:
x.file.close()
y.shape = (y.shape[0], y.shape[1] // n, n)
return y |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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)
if not data.ndim == 3 and data.shape[-1] in (3, 4):
raise ValueError('data must be a 3D array with last dimension 3 or 4')
with open(filename, 'wb') as f:
f.write(_make_png(data)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 Image data. See also -------- imsave, read_png, write_png """ |
imageio, PIL = _check_img_lib()
if imageio is not None:
return imageio.imread(filename, format)
elif PIL is not None:
im = PIL.Image.open(filename)
if im.mode == 'P':
im = im.convert()
# Make numpy array
a = np.asarray(im)
if len(a.shape) == 0:
raise MemoryError("Too little memory to convert PIL image to "
"array")
return a
else:
raise RuntimeError("imread requires the imageio or PIL package.") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 also -------- imread, read_png, write_png """ |
# Import imageio or PIL
imageio, PIL = _check_img_lib()
if imageio is not None:
return imageio.imsave(filename, im, format)
elif PIL is not None:
pim = PIL.Image.fromarray(im)
pim.save(filename, format)
else:
raise RuntimeError("imsave requires the imageio or PIL package.") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| 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],
'description' : o[1] }
return builtin_slots |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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. """ |
# store Timer kwargs in local variable so the namespace isn't polluted
# by different level args and kwargs
def wrapped_f(f):
@functools.wraps(f)
def wrapped(*args, **kwargs):
with Timer(**timer_kwargs) as t:
out = f(*args, **kwargs)
context = {
'function_name': f.__name__,
'execution_time': t.elapsed,
}
if logger:
logger.log(
level,
fmt % context,
extra=context)
else:
print(fmt % context)
return out
return wrapped
if (len(func_or_func_args) == 1
and isinstance(func_or_func_args[0], collections.Callable)):
return wrapped_f(func_or_func_args[0])
else:
return wrapped_f |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 : instance of Canvas The resulting vispy Canvas. """ |
renderer = VispyRenderer()
exporter = Exporter(renderer)
with warnings.catch_warnings(record=True): # py3k mpl warning
exporter.run(fig)
renderer._vispy_done()
return renderer.canvas |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 created. """ |
if not has_matplotlib():
raise ImportError('Requires matplotlib version >= 1.2')
cs = [_mpl_to_vispy(plt.figure(ii)) for ii in plt.get_fignums()]
if block and len(cs) > 0:
cs[0].app.run()
return cs |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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!') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 generate the vertices for arrows, which can be passed to an ArrowVisual. random_state : instance of RandomState | int | None Random state to use. Can be None to use ``np.random``. Yields ------ (node_vertices, line_vertices, arrow_vertices) : tuple Yields the node and line vertices in a tuple. This layout only yields a single time, and has no builtin animation """ |
if random_state is None:
random_state = np.random
elif not isinstance(random_state, np.random.RandomState):
random_state = np.random.RandomState(random_state)
if issparse(adjacency_mat):
adjacency_mat = adjacency_mat.tocoo()
# Randomly place nodes, visual coordinate system is between 0 and 1
num_nodes = adjacency_mat.shape[0]
node_coords = random_state.rand(num_nodes, 2)
line_vertices, arrows = _straight_line_vertices(adjacency_mat,
node_coords, directed)
yield node_coords, line_vertices, arrows |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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
return ev |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 isinstance(enum, string_types):
res = enum.lower()
# Check
if res is None:
raise ValueError('Could not determine string represenatation for'
'enum %r' % enum)
elif valid and res not in valid:
raise ValueError('Value of %s must be one of %r, not %r' %
(name, valid, enum))
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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.], [-1., 1.], [1., -1.], [1., 1.]]
program['a_texcoord'] = [[0., 1.], [0., 0.], [1., 1.], [1., 0.]]
program.draw('triangle_strip') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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, out)
if match:
return func(*map(float, match.groups())) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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"]:
(total_major_axis, total_minor_axis) = (total_halfx, total_halfy)
else:
(total_major_axis, total_minor_axis) = (total_halfy, total_halfx)
major_axis = total_major_axis * (1.0 -
ColorBarWidget.major_axis_padding)
minor_axis = major_axis * ColorBarWidget.minor_axis_ratio
# if the minor axis is "leaking" from the padding, then clamp
minor_axis = np.minimum(minor_axis,
total_minor_axis *
(1.0 - ColorBarWidget.minor_axis_padding))
return (major_axis, minor_axis) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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'), ('a', 'f4')])] level 0: ['color,vertex,normal,', 10, 'float32'] level 1: [['color', 4, 'float32'] ['normal', 3, 'float32'] ['vertex', 3, 'float32']] """ |
dtype = np.dtype(dtype)
fields = dtype.fields
# No fields
if fields is None:
if len(dtype.shape):
count = reduce(mul, dtype.shape)
else:
count = 1
# size = dtype.itemsize / count
if dtype.subdtype:
name = str(dtype.subdtype[0])
else:
name = str(dtype)
return ['', count, name]
else:
items = []
name = ''
# Get reduced fields
for key, value in fields.items():
l = dtype_reduce(value[0], level, depth + 1)
if type(l[0]) is str:
items.append([key, l[1], l[2]])
else:
items.append(l)
name += key + ','
# Check if we can reduce item list
ctype = None
count = 0
for i, item in enumerate(items):
# One item is a list, we cannot reduce
if type(item[0]) is not str:
return items
else:
if i == 0:
ctype = item[2]
count += item[1]
else:
if item[2] != ctype:
return items
count += item[1]
if depth >= level:
return [name, count, ctype]
else:
return items |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 'cube'). depth : int Number of depth segments (for method='cube'). radius : float Sphere radius. offset : bool Rotate each row by half a column (for method='latitude'). subdivisions : int Number of subdivisions to perform (for method='ico') method : str Method for generating sphere. Accepts 'latitude' for latitude- longitude, 'ico' for icosahedron, and 'cube' for cube based tessellation. Returns ------- sphere : MeshData Vertices and faces computed for a spherical surface. """ |
if method == 'latitude':
return _latitude(rows, cols, radius, offset)
elif method == 'ico':
return _ico(radius, subdivisions)
elif method == 'cube':
return _cube(rows, cols, depth, radius)
else:
raise Exception("Invalid method. Accepts: 'latitude', 'ico', 'cube'") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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. offset : bool Rotate each row by half a column. Returns ------- cylinder : MeshData Vertices and faces computed for a cylindrical surface. """ |
verts = np.empty((rows+1, cols, 3), dtype=np.float32)
if isinstance(radius, int):
radius = [radius, radius] # convert to list
# compute vertices
th = np.linspace(2 * np.pi, 0, cols).reshape(1, cols)
# radius as a function of z
r = np.linspace(radius[0], radius[1], num=rows+1,
endpoint=True).reshape(rows+1, 1)
verts[..., 2] = np.linspace(0, length, num=rows+1,
endpoint=True).reshape(rows+1, 1) # z
if offset:
# rotate each row by 1/2 column
th = th + ((np.pi / cols) * np.arange(rows+1).reshape(rows+1, 1))
verts[..., 0] = r * np.cos(th) # x = r cos(th)
verts[..., 1] = r * np.sin(th) # y = r sin(th)
# just reshape: no redundant vertices...
verts = verts.reshape((rows+1)*cols, 3)
# compute faces
faces = np.empty((rows*cols*2, 3), dtype=np.uint32)
rowtemplate1 = (((np.arange(cols).reshape(cols, 1) +
np.array([[0, 1, 0]])) % cols) +
np.array([[0, 0, cols]]))
rowtemplate2 = (((np.arange(cols).reshape(cols, 1) +
np.array([[0, 1, 1]])) % cols) +
np.array([[cols, 0, cols]]))
for row in range(rows):
start = row * cols * 2
faces[start:start+cols] = rowtemplate1 + row * cols
faces[start+cols:start+(cols*2)] = rowtemplate2 + row * cols
return MeshData(vertices=verts, faces=faces) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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. length : float Length of the arrow. cone_radius : float Radius of the cone base. If None, then this defaults to 2x the cylinder radius. cone_length : float Length of the cone. If None, then this defaults to 1/3 of the arrow length. Returns ------- arrow : MeshData Vertices and faces computed for a cone surface. """ |
# create the cylinder
md_cyl = None
if cone_radius is None:
cone_radius = radius*2.0
if cone_length is None:
con_L = length/3.0
cyl_L = length*2.0/3.0
else:
cyl_L = max(0, length - cone_length)
con_L = min(cone_length, length)
if cyl_L != 0:
md_cyl = create_cylinder(rows, cols, radius=[radius, radius],
length=cyl_L)
# create the cone
md_con = create_cone(cols, radius=cone_radius, length=con_L)
verts = md_con.get_vertices()
nbr_verts_con = verts.size//3
faces = md_con.get_faces()
if md_cyl is not None:
trans = np.array([[0.0, 0.0, cyl_L]])
verts = np.vstack((verts+trans, md_cyl.get_vertices()))
faces = np.vstack((faces, md_cyl.get_faces()+nbr_verts_con))
return MeshData(vertices=verts, faces=faces) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| 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
have the same dimensions as ys and zs.
ys : ndarray
A 2d array of y coordinates for the vertices of the mesh. Must
have the same dimensions as xs and zs.
zs : ndarray
A 2d array of z coordinates for the vertices of the mesh. Must
have the same dimensions as xs and ys.
Returns
-------
vertices : ndarray
The array of vertices in the mesh.
indices : ndarray
The array of indices for the mesh.
'''
shape = xs.shape
length = shape[0] * shape[1]
vertices = np.zeros((length, 3))
vertices[:, 0] = xs.reshape(length)
vertices[:, 1] = ys.reshape(length)
vertices[:, 2] = zs.reshape(length)
basic_indices = np.array([0, 1, 1 + shape[1], 0,
0 + shape[1], 1 + shape[1]],
dtype=np.uint32)
inner_grid_length = (shape[0] - 1) * (shape[1] - 1)
offsets = np.arange(inner_grid_length)
offsets += np.repeat(np.arange(shape[0] - 1), shape[1] - 1)
offsets = np.repeat(offsets, 6)
indices = np.resize(basic_indices, len(offsets)) + offsets
indices = indices.reshape((len(indices) // 3, 3))
return vertices, indices |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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 The adjacency matrix of the graph node_coords : array The current coordinates of all nodes in the graph directed : bool Wether the graph is directed. If this is true it will also generate the vertices for arrows which can be passed to :class:`ArrowVisual`. Returns ------- vertices : tuple Returns a tuple containing containing (`line_vertices`, `arrow_vertices`) """ |
if not issparse(adjacency_mat):
adjacency_mat = np.asarray(adjacency_mat, float)
if (adjacency_mat.ndim != 2 or adjacency_mat.shape[0] !=
adjacency_mat.shape[1]):
raise ValueError("Adjacency matrix should be square.")
arrow_vertices = np.array([])
edges = _get_edges(adjacency_mat)
line_vertices = node_coords[edges.ravel()]
if directed:
arrows = np.array(list(_get_directed_edges(adjacency_mat)))
arrow_vertices = node_coords[arrows.ravel()]
arrow_vertices = arrow_vertices.reshape((len(arrow_vertices)/2, 4))
return line_vertices, arrow_vertices |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| 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__ |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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` * None : Creates :class:`Camera` Notes ----- All extra arguments are passed to the __init__ method of the selected Camera class. """ |
cam_types = {None: BaseCamera}
for camType in (BaseCamera, PanZoomCamera, PerspectiveCamera,
TurntableCamera, FlyCamera, ArcballCamera):
cam_types[camType.__name__[:-6].lower()] = camType
try:
return cam_types[cam_type](*args, **kwargs)
except KeyError:
raise KeyError('Unknown camera type "%s". Options are: %s' %
(cam_type, cam_types.keys())) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
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),
('texcoord', np.float32, 2),
('normal', np.float32, 3)]
itype = np.uint32
# umin, umax, ucount = 0, 2*np.pi, 64
# vmin, vmax, vcount = 0, 2*np.pi, 64
vcount += 1
ucount += 1
n = vcount * ucount
Un = np.repeat(np.linspace(0, 1, ucount, endpoint=True), vcount)
Vn = np.tile(np.linspace(0, 1, vcount, endpoint=True), ucount)
U = umin + Un * (umax - umin)
V = vmin + Vn * (vmax - vmin)
vertices = np.zeros(n, dtype=vtype)
for i, (u, v) in enumerate(zip(U, V)):
vertices["position"][i] = func(u, v)
vertices["texcoord"][:, 0] = Un * urepeat
vertices["texcoord"][:, 1] = Vn * vrepeat
indices = []
for i in range(ucount - 1):
for j in range(vcount - 1):
indices.append(i * (vcount) + j)
indices.append(i * (vcount) + j + 1)
indices.append(i * (vcount) + j + vcount + 1)
indices.append(i * (vcount) + j + vcount)
indices.append(i * (vcount) + j + vcount + 1)
indices.append(i * (vcount) + j)
indices = np.array(indices, dtype=itype)
vertices["normal"] = normals(vertices["position"],
indices.reshape(len(indices) / 3, 3))
return vertices, indices |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _new_program(self, p):
"""New program was added to the multiprogram; update items in the shader. """ |
for k, v in self._set_items.items():
getattr(p, self._shader)[k] = v |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def attach(self, canvas):
"""Attach this tranform to a canvas Parameters canvas : instance of Canvas The canvas. """ |
self._canvas = canvas
canvas.events.resize.connect(self.on_resize)
canvas.events.mouse_wheel.connect(self.on_mouse_wheel)
canvas.events.mouse_move.connect(self.on_mouse_move) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def on_mouse_move(self, event):
"""Mouse move handler Parameters event : instance of Event The event. """ |
if event.is_dragging:
dxy = event.pos - event.last_event.pos
button = event.press_event.button
if button == 1:
dxy = self.canvas_tr.map(dxy)
o = self.canvas_tr.map([0, 0])
t = dxy - o
self.move(t)
elif button == 2:
center = self.canvas_tr.map(event.press_event.pos)
if self._aspect is None:
self.zoom(np.exp(dxy * (0.01, -0.01)), center)
else:
s = dxy[1] * -0.01
self.zoom(np.exp(np.array([s, s])), center)
self.shader_map() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def on_mouse_wheel(self, event):
"""Mouse wheel handler Parameters event : instance of Event The event. """ |
self.zoom(np.exp(event.delta * (0.01, -0.01)), event.pos) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def _frenet_frames(points, closed):
'''Calculates and returns the tangents, normals and binormals for
the tube.'''
tangents = np.zeros((len(points), 3))
normals = np.zeros((len(points), 3))
epsilon = 0.0001
# Compute tangent vectors for each segment
tangents = np.roll(points, -1, axis=0) - np.roll(points, 1, axis=0)
if not closed:
tangents[0] = points[1] - points[0]
tangents[-1] = points[-1] - points[-2]
mags = np.sqrt(np.sum(tangents * tangents, axis=1))
tangents /= mags[:, np.newaxis]
# Get initial normal and binormal
t = np.abs(tangents[0])
smallest = np.argmin(t)
normal = np.zeros(3)
normal[smallest] = 1.
vec = np.cross(tangents[0], normal)
normals[0] = np.cross(tangents[0], vec)
# Compute normal and binormal vectors along the path
for i in range(1, len(points)):
normals[i] = normals[i-1]
vec = np.cross(tangents[i-1], tangents[i])
if norm(vec) > epsilon:
vec /= norm(vec)
theta = np.arccos(np.clip(tangents[i-1].dot(tangents[i]), -1, 1))
normals[i] = rotate(-np.degrees(theta),
vec)[:3, :3].dot(normals[i])
if closed:
theta = np.arccos(np.clip(normals[0].dot(normals[-1]), -1, 1))
theta /= len(points) - 1
if tangents[0].dot(np.cross(normals[0], normals[-1])) > 0:
theta *= -1.
for i in range(1, len(points)):
normals[i] = rotate(-np.degrees(theta*i),
tangents[i])[:3, :3].dot(normals[i])
binormals = np.cross(tangents, normals)
return tangents, normals, binormals |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def max_order(self):
""" Depth of the smallest HEALPix cells found in the MOC instance. """ |
# TODO: cache value
combo = int(0)
for iv in self._interval_set._intervals:
combo |= iv[0] | iv[1]
ret = AbstractMOC.HPY_MAX_NORDER - (utils.number_trailing_zeros(combo) // 2)
if ret < 0:
ret = 0
return ret |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def intersection(self, another_moc, *args):
""" Intersection between the MOC instance and other MOCs. Parameters another_moc : `~mocpy.moc.MOC` The MOC used for performing the intersection with self. args : `~mocpy.moc.MOC` Other additional MOCs to perform the intersection with. Returns ------- result : `~mocpy.moc.MOC`/`~mocpy.tmoc.TimeMOC` The resulting MOC. """ |
interval_set = self._interval_set.intersection(another_moc._interval_set)
for moc in args:
interval_set = interval_set.intersection(moc._interval_set)
return self.__class__(interval_set) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def union(self, another_moc, *args):
""" Union between the MOC instance and other MOCs. Parameters another_moc : `~mocpy.moc.MOC` The MOC used for performing the union with self. args : `~mocpy.moc.MOC` Other additional MOCs to perform the union with. Returns ------- result : `~mocpy.moc.MOC`/`~mocpy.tmoc.TimeMOC` The resulting MOC. """ |
interval_set = self._interval_set.union(another_moc._interval_set)
for moc in args:
interval_set = interval_set.union(moc._interval_set)
return self.__class__(interval_set) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def difference(self, another_moc, *args):
""" Difference between the MOC instance and other MOCs. Parameters another_moc : `~mocpy.moc.MOC` The MOC used that will be substracted to self. args : `~mocpy.moc.MOC` Other additional MOCs to perform the difference with. Returns ------- result : `~mocpy.moc.MOC` or `~mocpy.tmoc.TimeMOC` The resulting MOC. """ |
interval_set = self._interval_set.difference(another_moc._interval_set)
for moc in args:
interval_set = interval_set.difference(moc._interval_set)
return self.__class__(interval_set) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _neighbour_pixels(hp, ipix):
""" Returns all the pixels neighbours of ``ipix`` """ |
neigh_ipix = np.unique(hp.neighbours(ipix).ravel())
# Remove negative pixel values returned by `~astropy_healpix.HEALPix.neighbours`
return neigh_ipix[np.where(neigh_ipix >= 0)] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def from_cells(cls, cells):
""" Creates a MOC from a numpy array representing the HEALPix cells. Parameters cells : `numpy.ndarray` Must be a numpy structured array (See https://docs.scipy.org/doc/numpy-1.15.0/user/basics.rec.html). The structure of a cell contains 3 attributes: - A `ipix` value being a np.uint64 - A `depth` value being a np.uint32 - A `fully_covered` flag bit stored in a np.uint8 Returns ------- moc : `~mocpy.moc.MOC` The MOC. """ |
shift = (AbstractMOC.HPY_MAX_NORDER - cells["depth"]) << 1
p1 = cells["ipix"]
p2 = cells["ipix"] + 1
intervals = np.vstack((p1 << shift, p2 << shift)).T
return cls(IntervalSet(intervals)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def from_json(cls, json_moc):
""" Creates a MOC from a dictionary of HEALPix cell arrays indexed by their depth. Parameters json_moc : dict(str : [int] A dictionary of HEALPix cell arrays indexed by their depth. Returns ------- moc : `~mocpy.moc.MOC` or `~mocpy.tmoc.TimeMOC` the MOC. """ |
intervals = np.array([])
for order, pix_l in json_moc.items():
if len(pix_l) == 0:
continue
pix = np.array(pix_l)
p1 = pix
p2 = pix + 1
shift = 2 * (AbstractMOC.HPY_MAX_NORDER - int(order))
itv = np.vstack((p1 << shift, p2 << shift)).T
if intervals.size == 0:
intervals = itv
else:
intervals = np.vstack((intervals, itv))
return cls(IntervalSet(intervals)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _uniq_pixels_iterator(self):
""" Generator giving the NUNIQ HEALPix pixels of the MOC. Returns ------- uniq : the NUNIQ HEALPix pixels iterator """ |
intervals_uniq_l = IntervalSet.to_nuniq_interval_set(self._interval_set)._intervals
for uniq_iv in intervals_uniq_l:
for uniq in range(uniq_iv[0], uniq_iv[1]):
yield uniq |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def from_fits(cls, filename):
""" Loads a MOC from a FITS file. The specified FITS file must store the MOC (i.e. the list of HEALPix cells it contains) in a binary HDU table. Parameters filename : str The path to the FITS file. Returns ------- result : `~mocpy.moc.MOC` or `~mocpy.tmoc.TimeMOC` The resulting MOC. """ |
table = Table.read(filename)
intervals = np.vstack((table['UNIQ'], table['UNIQ']+1)).T
nuniq_interval_set = IntervalSet(intervals)
interval_set = IntervalSet.from_nuniq_interval_set(nuniq_interval_set)
return cls(interval_set) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_json(uniq):
""" Serializes a MOC to the JSON format. Parameters uniq : `~numpy.ndarray` The array of HEALPix cells representing the MOC to serialize. Returns ------- result_json : {str : [int]} A dictionary of HEALPix cell lists indexed by their depth. """ |
result_json = {}
depth, ipix = utils.uniq2orderipix(uniq)
min_depth = np.min(depth[0])
max_depth = np.max(depth[-1])
for d in range(min_depth, max_depth+1):
pix_index = np.where(depth == d)[0]
if pix_index.size:
# there are pixels belonging to the current order
ipix_depth = ipix[pix_index]
result_json[str(d)] = ipix_depth.tolist()
return result_json |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_str(uniq):
""" Serializes a MOC to the STRING format. HEALPix cells are separated by a comma. The HEALPix cell at order 0 and number 10 is encoded by the string: "0/10", the first digit representing the depth and the second the HEALPix cell number for this depth. HEALPix cells next to each other within a specific depth can be expressed as a range and therefore written like that: "12/10-150". This encodes the list of HEALPix cells from 10 to 150 at the depth 12. Parameters uniq : `~numpy.ndarray` The array of HEALPix cells representing the MOC to serialize. Returns ------- result : str The serialized MOC. """ |
def write_cells(serial, a, b, sep=''):
if a == b:
serial += '{0}{1}'.format(a, sep)
else:
serial += '{0}-{1}{2}'.format(a, b, sep)
return serial
res = ''
if uniq.size == 0:
return res
depth, ipixels = utils.uniq2orderipix(uniq)
min_depth = np.min(depth[0])
max_depth = np.max(depth[-1])
for d in range(min_depth, max_depth+1):
pix_index = np.where(depth == d)[0]
if pix_index.size > 0:
# Serialize the depth followed by a slash
res += '{0}/'.format(d)
# Retrieve the pixel(s) for this depth
ipix_depth = ipixels[pix_index]
if ipix_depth.size == 1:
# If there is only one pixel we serialize it and
# go to the next depth
res = write_cells(res, ipix_depth[0], ipix_depth[0])
else:
# Sort them in case there are several
ipix_depth = np.sort(ipix_depth)
beg_range = ipix_depth[0]
last_range = beg_range
# Loop over the sorted pixels by tracking the lower bound of
# the current range and the last pixel.
for ipix in ipix_depth[1:]:
# If the current pixel does not follow the previous one
# then we can end a range and serializes it
if ipix > last_range + 1:
res = write_cells(res, beg_range, last_range, sep=',')
# The current pixel is the beginning of a new range
beg_range = ipix
last_range = ipix
# Write the last range
res = write_cells(res, beg_range, last_range)
# Add a ' ' separator before writing serializing the pixels of the next depth
res += ' '
# Remove the last ' ' character
res = res[:-1]
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _to_fits(self, uniq, optional_kw_dict=None):
""" Serializes a MOC to the FITS format. Parameters uniq : `numpy.ndarray` The array of HEALPix cells representing the MOC to serialize. optional_kw_dict : dict Optional keywords arguments added to the FITS header. Returns ------- thdulist : `astropy.io.fits.HDUList` The list of HDU tables. """ |
depth = self.max_order
if depth <= 13:
fits_format = '1J'
else:
fits_format = '1K'
tbhdu = fits.BinTableHDU.from_columns(
fits.ColDefs([
fits.Column(name='UNIQ', format=fits_format, array=uniq)
]))
tbhdu.header['PIXTYPE'] = 'HEALPIX'
tbhdu.header['ORDERING'] = 'NUNIQ'
tbhdu.header.update(self._fits_header_keywords)
tbhdu.header['MOCORDER'] = depth
tbhdu.header['MOCTOOL'] = 'MOCPy'
if optional_kw_dict:
for key in optional_kw_dict:
tbhdu.header[key] = optional_kw_dict[key]
thdulist = fits.HDUList([fits.PrimaryHDU(), tbhdu])
return thdulist |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def serialize(self, format='fits', optional_kw_dict=None):
""" Serializes the MOC into a specific format. Possible formats are FITS, JSON and STRING Parameters format : str 'fits' by default. The other possible choice is 'json' or 'str'. optional_kw_dict : dict Optional keywords arguments added to the FITS header. Only used if ``format`` equals to 'fits'. Returns ------- result : `astropy.io.fits.HDUList` or JSON dictionary The result of the serialization. """ |
formats = ('fits', 'json', 'str')
if format not in formats:
raise ValueError('format should be one of %s' % (str(formats)))
uniq_l = []
for uniq in self._uniq_pixels_iterator():
uniq_l.append(uniq)
uniq = np.array(uniq_l)
if format == 'fits':
result = self._to_fits(uniq=uniq,
optional_kw_dict=optional_kw_dict)
elif format == 'str':
result = self.__class__._to_str(uniq=uniq)
else:
# json format serialization
result = self.__class__._to_json(uniq=uniq)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, path, format='fits', overwrite=False, optional_kw_dict=None):
""" Writes the MOC to a file. Format can be 'fits' or 'json', though only the fits format is officially supported by the IVOA. Parameters path : str, optional The path to the file to save the MOC in. format : str, optional The format in which the MOC will be serialized before being saved. Possible formats are "fits" or "json". By default, ``format`` is set to "fits". overwrite : bool, optional If the file already exists and you want to overwrite it, then set the ``overwrite`` keyword. Default to False. optional_kw_dict : optional Optional keywords arguments added to the FITS header. Only used if ``format`` equals to 'fits'. """ |
serialization = self.serialize(format=format, optional_kw_dict=optional_kw_dict)
if format == 'fits':
serialization.writeto(path, overwrite=overwrite)
else:
import json
with open(path, 'w') as h:
h.write(json.dumps(serialization, sort_keys=True, indent=2)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def degrade_to_order(self, new_order):
""" Degrades the MOC instance to a new, less precise, MOC. The maximum depth (i.e. the depth of the smallest HEALPix cells that can be found in the MOC) of the degraded MOC is set to ``new_order``. Parameters new_order : int Maximum depth of the output degraded MOC. Returns ------- moc : `~mocpy.moc.MOC` or `~mocpy.tmoc.TimeMOC` The degraded MOC. """ |
shift = 2 * (AbstractMOC.HPY_MAX_NORDER - new_order)
ofs = (int(1) << shift) - 1
mask = ~ofs
adda = int(0)
addb = ofs
iv_set = []
for iv in self._interval_set._intervals:
a = (iv[0] + adda) & mask
b = (iv[1] + addb) & mask
if b > a:
iv_set.append((a, b))
return self.__class__(IntervalSet(np.asarray(iv_set))) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_name(self, name):
""" Set Screen Name """ |
self.name = name
self.server.request("screen_set %s name %s" % (self.ref, self.name)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_width(self, width):
""" Set Screen Width """ |
if width > 0 and width <= self.server.server_info.get("screen_width"):
self.width = width
self.server.request("screen_set %s wid %i" % (self.ref, self.width)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_height(self, height):
""" Set Screen Height """ |
if height > 0 and height <= self.server.server_info.get("screen_height"):
self.height = height
self.server.request("screen_set %s hgt %i" % (self.ref, self.height)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_cursor_x(self, x):
""" Set Screen Cursor X Position """ |
if x >= 0 and x <= self.server.server_info.get("screen_width"):
self.cursor_x = x
self.server.request("screen_set %s cursor_x %i" % (self.ref, self.cursor_x)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_cursor_y(self, y):
""" Set Screen Cursor Y Position """ |
if y >= 0 and y <= self.server.server_info.get("screen_height"):
self.cursor_y = y
self.server.request("screen_set %s cursor_y %i" % (self.ref, self.cursor_y)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_duration(self, duration):
""" Set Screen Change Interval Duration """ |
if duration > 0:
self.duration = duration
self.server.request("screen_set %s duration %i" % (self.ref, (self.duration * 8))) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_timeout(self, timeout):
""" Set Screen Timeout Duration """ |
if timeout > 0:
self.timeout = timeout
self.server.request("screen_set %s timeout %i" % (self.ref, (self.timeout * 8))) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_priority(self, priority):
""" Set Screen Priority Class """ |
if priority in ["hidden", "background", "info", "foreground", "alert", "input"]:
self.priority = priority
self.server.request("screen_set %s priority %s" % (self.ref, self.priority)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_backlight(self, state):
""" Set Screen Backlight Mode """ |
if state in ["on", "off", "toggle", "open", "blink", "flash"]:
self.backlight = state
self.server.request("screen_set %s backlight %s" % (self.ref, self.backlight)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_heartbeat(self, state):
""" Set Screen Heartbeat Display Mode """ |
if state in ["on", "off", "open"]:
self.heartbeat = state
self.server.request("screen_set %s heartbeat %s" % (self.ref, self.heartbeat)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_cursor(self, cursor):
""" Set Screen Cursor Mode """ |
if cursor in ["on", "off", "under", "block"]:
self.cursor = cursor
self.server.request("screen_set %s cursor %s" % (self.ref, self.cursor)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_string_widget(self, ref, text="Text", x=1, y=1):
""" Add String Widget """ |
if ref not in self.widgets:
widget = widgets.StringWidget(screen=self, ref=ref, text=text, x=x, y=y)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_title_widget(self, ref, text="Title"):
""" Add Title Widget """ |
if ref not in self.widgets:
widget = widgets.TitleWidget(screen=self, ref=ref, text=text)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_hbar_widget(self, ref, x=1, y=1, length=10):
""" Add Horizontal Bar Widget """ |
if ref not in self.widgets:
widget = widgets.HBarWidget(screen=self, ref=ref, x=x, y=y, length=length)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_vbar_widget(self, ref, x=1, y=1, length=10):
""" Add Vertical Bar Widget """ |
if ref not in self.widgets:
widget = widgets.VBarWidget(screen=self, ref=ref, x=x, y=y, length=length)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_frame_widget(self, ref, left=1, top=1, right=20, bottom=1, width=20, height=4, direction="h", speed=1):
""" Add Frame Widget """ |
if ref not in self.widgets:
widget = widgets.FrameWidget(
screen=self, ref=ref, left=left, top=top, right=right, bottom=bottom, width=width, height=height,
direction=direction, speed=speed,
)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_number_widget(self, ref, x=1, value=1):
""" Add Number Widget """ |
if ref not in self.widgets:
widget = widgets.NumberWidget(screen=self, ref=ref, x=x, value=value)
self.widgets[ref] = widget
return self.widgets[ref] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def orbit(self, azim, elev):
""" Orbits the camera around the center position. Parameters azim : float Angle in degrees to rotate horizontally around the center point. elev : float Angle in degrees to rotate vertically around the center point. """ |
self.azimuth += azim
self.elevation = np.clip(self.elevation + elev, -90, 90)
self.view_changed() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _set_config(c):
"""Set gl configuration for GLFW """ |
glfw.glfwWindowHint(glfw.GLFW_RED_BITS, c['red_size'])
glfw.glfwWindowHint(glfw.GLFW_GREEN_BITS, c['green_size'])
glfw.glfwWindowHint(glfw.GLFW_BLUE_BITS, c['blue_size'])
glfw.glfwWindowHint(glfw.GLFW_ALPHA_BITS, c['alpha_size'])
glfw.glfwWindowHint(glfw.GLFW_ACCUM_RED_BITS, 0)
glfw.glfwWindowHint(glfw.GLFW_ACCUM_GREEN_BITS, 0)
glfw.glfwWindowHint(glfw.GLFW_ACCUM_BLUE_BITS, 0)
glfw.glfwWindowHint(glfw.GLFW_ACCUM_ALPHA_BITS, 0)
glfw.glfwWindowHint(glfw.GLFW_DEPTH_BITS, c['depth_size'])
glfw.glfwWindowHint(glfw.GLFW_STENCIL_BITS, c['stencil_size'])
# glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, c['major_version'])
# glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, c['minor_version'])
# glfw.glfwWindowHint(glfw.GLFW_SRGB_CAPABLE, c['srgb'])
glfw.glfwWindowHint(glfw.GLFW_SAMPLES, c['samples'])
glfw.glfwWindowHint(glfw.GLFW_STEREO, c['stereo'])
if not c['double_buffer']:
raise RuntimeError('GLFW must double buffer, consider using a '
'different backend, or using double buffering') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _patch():
""" Monkey-patch pyopengl to fix a bug in glBufferSubData. """ |
import sys
from OpenGL import GL
if sys.version_info > (3,):
buffersubdatafunc = GL.glBufferSubData
if hasattr(buffersubdatafunc, 'wrapperFunction'):
buffersubdatafunc = buffersubdatafunc.wrapperFunction
_m = sys.modules[buffersubdatafunc.__module__]
_m.long = int
# Fix missing enum
try:
from OpenGL.GL.VERSION import GL_2_0
GL_2_0.GL_OBJECT_SHADER_SOURCE_LENGTH = GL_2_0.GL_SHADER_SOURCE_LENGTH
except Exception:
pass |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _inject():
""" Copy functions from OpenGL.GL into _pyopengl namespace. """ |
NS = _pyopengl2.__dict__
for glname, ourname in _pyopengl2._functions_to_import:
func = _get_function_from_pyopengl(glname)
NS[ourname] = func |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.