def run_movie_gui(filename):
print('Starting up movie gui...')
canvas = Canvas(filename)
vispy.use('PyQt5')
w = MainWindow(canvas)
w.show()
vispy.app.run()
def __init__(self, im, conf, roi, logger):
vispy.set_log_level('DEBUG')
try:
vispy.use(app='glfw', gl='gl+')
except RuntimeError as e:
pass
app.Canvas.__init__(self,
keys = 'interactive',
size = (conf['ipmWidth'], conf['ipmHeight']),
position = (0,0),
title = 'IPM',
show = False,
resizable = False)
self._rendertex = gloo.Texture2D(shape=(self.size[1], self.size[0], 4))
self._fbo = gloo.FrameBuffer(self._rendertex,
gloo.RenderBuffer((self.size[1], self.size[0])))
try:
fragmentShaderSourceString = open(FRAGMENT_SHADER_FILENAME).read()
except:
logger.fatal("%s does not exist !", FRAGMENT_SHADER_FILENAME)
sys.exit()
try:
vertexShaderSourceString = open(VERTEX_SHADER_FILENAME).read()
except:
logger.fatal("%s does not exist !", VERTEX_SHADER_FILENAME)
sys.exit()
self.program = gloo.Program(vertexShaderSourceString, fragmentShaderSourceString)
self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)]
gloo.set_viewport(0, 0, *self.size)
tex = gloo.Texture2D(im)
tex.interpolation = 'linear'
tex.wrapping = 'repeat'
self.program['iChannel'] = tex
if len(im.shape) == 3:
self.program['iChannelResolution'] = (im.shape[1], im.shape[0], im.shape[2])
else:
self.program['iChannelResolution'] = (im.shape[1], im.shape[0], 1)
self.program['iResolution'] = (self.size[0], self.size[1], 0.)
self.getUniforms(conf, roi)
self.update()
app.run()
return self
def __init__(self, config) -> None:
self.config = yaml.load(open(config, 'r'))
if os.name == 'nt':
vispy.use(app='pyqt5')
else:
vispy.use(app='egl')
if isinstance(self.config['gpu_ids'], int) and (self.config['gpu_ids'] >= 0):
self.device = self.config['gpu_ids']
else:
self.device = "cpu"
print(f"Loading edge model at {time.time()}")
self.depth_edge_model = Inpaint_Edge_Net(init_weights=True)
self.depth_edge_weight = torch.load(self.config['depth_edge_model_ckpt'],
map_location=torch.device(self.device))
self.depth_edge_model.load_state_dict(self.depth_edge_weight)
self.depth_edge_model = self.depth_edge_model.to(self.device)
self.depth_edge_model.eval()
print(f"Loading depth model at {time.time()}")
self.depth_feat_model = Inpaint_Depth_Net()
self.depth_feat_weight = torch.load(self.config['depth_feat_model_ckpt'],
map_location=torch.device(self.device))
self.depth_feat_model.load_state_dict(self.depth_feat_weight, strict=True)
self.depth_feat_model = self.depth_feat_model.to(self.device)
self.depth_feat_model.eval()
self.depth_feat_model = self.depth_feat_model.to(self.device)
print(f"Loading rgb model at {time.time()}")
self.rgb_model = Inpaint_Color_Net()
self.rgb_feat_weight = torch.load(self.config['rgb_feat_model_ckpt'],
map_location=torch.device(self.device))
self.rgb_model.load_state_dict(self.rgb_feat_weight)
self.rgb_model.eval()
self.rgb_model = self.rgb_model.to(self.device)
self.graph = None
def main():
parser = argparse.ArgumentParser(
description="Generate block images for Mapcrafter.")
parser.add_argument("--osmesa", action="store_true")
parser.add_argument("--no-render", action="store_true")
parser.add_argument("--texture-size", "-t", type=int, action="append")
parser.add_argument("--view", "-v", type=str, action="append")
parser.add_argument("--rotation", "-r", type=int, action="append")
parser.add_argument("--assets",
"-a",
type=str,
action="append",
required=True)
parser.add_argument("--blocks", "-b", type=str, action="append")
parser.add_argument("--output-dir", "-o", type=str, required=True)
args = parser.parse_args()
if args.osmesa:
import vispy
vispy.use("osmesa")
assert vispy.app.use_app().backend_name == "osmesa"
c = Canvas(args)
app.run()
headless = int(os.environ.get('PYMAID_HEADLESS', '0'))
if utils._type_of_script() == 'ipython':
if headless:
logger.info('Pymaid is running in headless mode')
elif utils.is_headless():
logger.info('No display detected. Pymaid is running in headless mode')
else:
try:
ipython = get_ipython()
ipython.magic("%gui qt5")
except BaseException:
pass
try:
# Try setting vispy backend to PyQt5
vispy.use(app='PyQt5')
except BaseException:
pass
def block_all(function):
"""Decorator to block all events on canvas and view."""
@wraps(function)
def wrapper(*args, **kwargs):
viewer = args[0]
viewer.canvas.events.block_all()
viewer.view3d.events.block_all()
try:
# Execute function
res = function(*args, **kwargs)
except BaseException:
#
# Part of p5: A Python package based on Processing
# Copyright (C) 2017-2019 Abhik Pal
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
from .userspace import *
import vispy
vispy.use('glfw')
# -*- coding: utf-8 -*-
# Copyright (c) 2015, Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
"""
This example shows how to retrieve event information from a callback.
You should see information displayed for any event you triggered.
"""
from vispy import gloo, app, use
use('pyqt4') # can be another app backend name
class Canvas(app.Canvas):
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
self.title = 'App demo'
def on_close(self, event):
print('closing!')
def on_resize(self, event):
print('Resize %r' % (event.size, ))
def on_key_press(self, event):
modifiers = [key.name for key in event.modifiers]
print('Key pressed - text: %r, key: %s, modifiers: %r' %
(event.text, event.key.name, modifiers))
def on_key_release(self, event):
modifiers = [key.name for key in event.modifiers]
# vispy: testskip
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
"""
This is a simple osmesa example that produce an image of a cube
If you have both osmesa and normal (X) OpenGL installed, execute with
something like the following to pickup the OSMesa libraries::
VISPY_GL_LIB=/opt/osmesa_llvmpipe/lib/libGLESv2.so \
LD_LIBRARY_PATH=/opt/osmesa_llvmpipe/lib/ \
OSMESA_LIBRARY=/opt/osmesa_llvmpipe/lib/libOSMesa.so \
python examples/offscreen/simple_osmesa.py
"""
import vispy
vispy.use(app='osmesa') # noqa
import numpy as np
import vispy.plot as vp
import vispy.io as io
# Check the application correctly picked up osmesa
assert vispy.app.use_app().backend_name == 'osmesa', 'Not using OSMesa'
data = np.load(io.load_data_file('electrophys/iv_curve.npz'))['arr_0']
time = np.arange(0, data.shape[1], 1e-4)
fig = vp.Fig(size=(800, 800), show=False)
x = np.linspace(0, 10, 20)
y = np.cos(x)
method. The instability of the Euler Method becomes apparent as the time step
is increased.
"""
from __future__ import division, print_function, absolute_import
from vispy import app, visuals
from vispy.visuals import transforms
from vispy.io import load_data_file
import sys
import numpy as np
import string
import logging
import traceback
from PyQt4 import QtGui, QtCore
import vispy
vispy.use('pyqt4')
logger = logging.getLogger(__name__)
VALID_METHODS = ['euler', 'runge-kutta']
PARAMETERS = [('d1', 0.0, 10.0, 'double', 0.97),
('d2', 0.0, 10.0, 'double', 0.55),
('m', 0.01, 100.0, 'double', 2.0),
('M', 0.01, 100.0, 'double', 12.5),
('k1', 0.01, 75.0, 'double', 1.35),
('k2', 0.01, 75.0, 'double', 0.50),
('b', 1.0, 1000.0, 'double', 25.75),
('time step', 0.001, 1.0, 'double', 1 / 60),
('x', -0.25, 0.25, 'double', -0.01),
('x dot', -10.0, 10.0, 'double', -0.12),
('theta', -np.pi / 5, np.pi / 5, 'double', 0.005),
Example demonstrating simulation of fireworks using point sprites.
(adapted from the "OpenGL ES 2.0 Programming Guide")
This example demonstrates a series of explosions that last one second. The
visualization during the explosion is highly optimized using a Vertex Buffer
Object (VBO). After each explosion, vertex data for the next explosion are
calculated, such that each explostion is unique.
"""
import time
import numpy as np
from vispy import gloo, app
import vispy
#vispy.use('pyside', 'es2')
vispy.use("pyqt5","gl+")
# Create a texture
radius = 32
im1 = np.random.normal(
0.8, 0.3, (radius * 2 + 1, radius * 2 + 1)).astype(np.float32)
# Mask it with a disk
L = np.linspace(-radius, radius, 2 * radius + 1)
(X, Y) = np.meshgrid(L, L)
im1 *= np.array((X ** 2 + Y ** 2) <= radius * radius, dtype='float32')
# Set number of particles, you should be able to scale this to 100000
N = 10000
# Create vertex data container
def wrap_3d_photo_inpainting(config_path, *,
depth_handler: Optional[FileChoose] = None,
bar_total: Optional[ComplexProgressBar] = None,
bar_current: Optional[ComplexProgressBar] = None,
just_depth: bool = False
):
bar_current.reset()
config = yaml.load(open(config_path, 'r'))
if config['offscreen_rendering'] is True:
vispy.use(app='egl')
init_fs(config)
sample_list = get_MiDaS_samples(config['src_folder'], config['depth_folder'], config, config['specific'])
normal_canvas, all_canvas = None, None
if isinstance(config["gpu_ids"], int) and (config["gpu_ids"] >= 0):
device = config["gpu_ids"]
else:
device = "cpu"
bar_current.add(bar_current.max)
bar_total.add(bar_total.max * 2 / 100)
print(f(_("running on device {device}")))
for idx in tqdm(range(len(sample_list))):
bar_current.reset()
depth = None
sample = sample_list[idx]
print(f(_("Current Source ==> {sample['src_pair_name']}")))
mesh_fi = os.path.join(config['mesh_folder'], sample['src_pair_name'] +'.ply')
image = imageio.imread(sample['ref_img_fi'])
print(f(_("Running depth extraction at {datetime.now():%Y-%m-%d %H:%M:%S.%f}")))
if just_depth or config['require_midas'] is True:
run_depth([sample['ref_img_fi']], config['src_folder'], config['depth_folder'],
config['MiDaS_model_ckpt'], MonoDepthNet, MiDaS_utils, target_w=640)
update_image_handler(image_handler=depth_handler,
path=Path(f"{config['depth_folder']}/{sample['src_pair_name']}.png"))
if just_depth:
bar_total.reset()
bar_total.value = bar_total.max
bar_current.reset()
bar_current.value = bar_current.max
return
bar_current.add(bar_current.max)
bar_total.add(bar_total.max * (2 / len(sample_list)) / 100)
bar_current.reset()
image = prepare_config_and_image(config=config, sample=sample, image=image)
bar_current.add(bar_current.max)
bar_total.add(bar_total.max * (2 / len(sample_list)) / 100)
bar_current.reset()
image = cv2.resize(image, (config['output_w'], config['output_h']), interpolation=cv2.INTER_AREA)
depth = read_MiDaS_depth(sample['depth_fi'], 3.0, config['output_h'], config['output_w'])
mean_loc_depth = depth[depth.shape[0]//2, depth.shape[1]//2]
bar_current.add(bar_current.max)
bar_total.add(bar_total.max * (2 / len(sample_list)) / 100)
bar_current.reset()
if not(config['load_ply'] is True and os.path.exists(mesh_fi)):
vis_photos, vis_depths = sparse_bilateral_filtering(depth.copy(), image.copy(), config, num_iter=config['sparse_iter'], spdb=False)
depth = vis_depths[-1]
model = None
torch.cuda.empty_cache()
print(_("Start Running 3D_Photo ..."))
depth_edge_model = load_edge_model(device=device, depth_edge_model_ckpt=config['depth_edge_model_ckpt'])
depth_edge_model.eval()
depth_feat_model = load_depth_model(device=device, depth_feat_model_ckpt=config['depth_feat_model_ckpt'])
rgb_model = load_rgb_model(device=device, rgb_feat_model_ckpt=config['rgb_feat_model_ckpt'])
graph = None
def up_bars(dt=None):
bar_current.add(bar_current.max * 1.5 / 100)
bar_total.add(bar_total.max * (1 / len(sample_list)) / 100)
# increase the bars every 5 sec, up to 5 min
event = schedule_interval(up_bars, 5, 60 * 5)
print(f(_("Writing depth ply (and basically doing everything) at {datetime.now():%Y-%m-%d %H:%M:%S.%f}")))
rt_info = write_ply(image,
depth,
sample['int_mtx'],
mesh_fi,
config,
rgb_model,
depth_edge_model,
depth_edge_model,
depth_feat_model)
if rt_info is False:
continue
rgb_model = None
color_feat_model = None
depth_edge_model = None
depth_feat_model = None
torch.cuda.empty_cache()
event.cancel()
bar_current.add(bar_current.max)
bar_total.value_normalized = 75 / 100
bar_current.reset()
props = read_ply(mesh_fi) if config['save_ply'] is True or config['load_ply'] is True else rt_info
make_video(
sample=sample, config=config, props=props,
depth=depth, normal_canvas=normal_canvas, all_canvas=all_canvas,
)
bar_current.value_normalized = 1
bar_total.value_normalized = 1
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This example shows how to actively select and test the pyglet backend.
You should see a black window and any mouse or keyboard event should be
detected. A timer is also run every second and it should print "tick !"
every second.
"""
from vispy import app, use, gloo
use('pyglet')
class Canvas(app.Canvas):
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
timer = app.Timer(1.0)
timer.connect(self.on_timer)
timer.start()
def on_initialize(self, event):
gloo.set_clear_color('black')
print('on_initialize')
def on_close(self, event):
print('on_close')
def on_resize(self, event):
print('on_resize (%dx%d)' % event.size)
timer.stop()
self._ready = True
timer.timeout.connect(_calc_vertices)
timer.start()
self.vertices = vertices
if __name__ == '__main__':
# load config params
try:
with open(CONFIG_FILE) as f:
config = json.load(f)
except FileNotFoundError:
print('config file not found.')
config = {'pre_rendering': True}
vispy.use('pyqt5')
canvas = scene.SceneCanvas(keys="interactive",
size=(1200, 800),
show=False)
camera = scene.TurntableCamera(up='+z')
myui = MyUi()
handler = UIHandler(myui,
canvas,
camera,
use_pre_rendering=config['pre_rendering'])
canvas.app.run()
import logging
logging.basicConfig(level=logging.DEBUG)
import xml.etree.ElementTree as ET
import numpy as np
import sys
if True:
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QGridLayout
from PyQt5.QtWidgets import QSpacerItem
from PyQt5.QtCore import QTimer
else:
pass
import vispy
vispy.use(app='PyQT5')
from vispy.plot import Fig
def typed(xml):
"""Convert XML value to Python types"""
type_ = xml.attrib['type']
# The type function may be within brackets
type_func = getattr(__builtins__, type_.strip('[]'))
if type_.startswith('['):
return [type_func(value.strip()) for value in xml.text.split(',')]
else:
return type_func(xml.text.strip())
clog = logging.getLogger('CinfFigure')
from rendkit import shortcuts
from terial import config, models
from terial.config import SUBSTANCES
from terial.materials import loader
from terial.classifier.data import collector
from terial.models import Shape, ExemplarShapePair, Exemplar
from terial.database import session_scope
from toolbox import cameras
from terial.pairs import utils
from terial.web.utils import make_http_client
from toolbox.images import visualize_map
import toolbox.images
import vispy
from toolbox.logging import init_logger
vispy.use(app='glfw') # noqa
logger = init_logger(__name__)
vis = visdom.Visdom(env='generate-data')
_TMP_MESH_PATH = '/tmp/_terial_generate_data_temp_mesh.obj'
_TMP_REND_PATH = '/tmp/_terial_generate_data_temp_rend.exr'
_REND_SHAPE = (500, 500)
@attr.s()
class _Envmap(object):
path: str = attr.ib()
rotation: Tuple[float, float, float] = attr.ib()
def cube(im_in, azimuth=30., elevation=45., name=None,
ext=ext, do_axis=True, show_label=True,
cube_label = {'x':'x', 'y':'y', 't':'t'},
colormap='gray', roll=-180., vmin=0., vmax=1.,
figsize=figsize, **kwargs):
"""
Visualization of the stimulus as a cube
"""
im = im_in.copy()
N_X, N_Y, N_frame = im.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
import numpy as np
from vispy import app, scene, use
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
use(app='pyglet', gl='pyopengl2')
from vispy.util.transforms import perspective, translate, rotate
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
# frame = scene.visuals.Cube(size = (N_X/2, N_frame/2, N_Y/2), color=(0., 0., 0., 0.),
# edge_color='k',
# parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
# line = scene.visuals.Line(pos=np.array([[p[0]*N_Y/2, p[1]*N_X/2, p[2]*N_frame/2], [p[3]*N_Y/2, p[4]*N_X/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_frame/2, p[2]*N_Y/2],
[p[3]*N_X/2, p[4]*N_frame/2, p[5]*N_Y/2]]), color='black', parent=view.scene)
opts = {'parent':view.scene, 'cmap':'grays', 'clim':(0., 1.)}
image_xy = scene.visuals.Image(np.rot90(im[:, :, 0], 3), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (1, 0, 0))
tr_xy.translate((-N_X/2, -N_frame/2, -N_Y/2))
image_xy.transform = tr_xy
image_xt = scene.visuals.Image(np.fliplr(im[:, -1, :]), **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (0, 0, 1))
tr_xt.translate((N_X/2, -N_frame/2, N_Y/2))
image_xt.transform = tr_xt
image_yt = scene.visuals.Image(np.rot90(im[-1, :, :], 1), **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((+N_X/2, -N_frame/2, N_Y/2))
image_yt.transform = tr_yt
if do_axis:
t = {}
for text in ['x', 'y', 't']:
t[text] = scene.visuals.Text(cube_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['t'].pos = canvas.size[0] - canvas.size[0] // 5, canvas.size[1] - canvas.size[1] // 6
t['y'].pos = canvas.size[0] // 12, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=35, azimuth=30)
cam.fov = 45
cam.scale_factor = N_X * 1.7
if do_axis: margin = 1.3
else: margin = 1
cam.set_range((-N_X/2, N_X/2), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2, N_frame/2))
view.camera = cam
if not(name is None):
im = canvas.render(size=figsize)
app.quit()
import vispy.io as io
io.write_png(name + ext, im)
else:
app.quit()
return im
def visualize(z_in, azimuth=25., elevation=30.,
thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],
# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],
# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],
fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},
name=None, ext=ext, do_axis=True, do_grids=False, draw_projections=True,
colorbar=False, f_N=2., f_tN=2., figsize=figsize, figpath=figpath, **kwargs):
"""
Visualization of the Fourier spectrum by showing 3D contour plots at different thresholds
parameters
----------
z : envelope of the cloud
"""
z = z_in.copy()
N_X, N_Y, N_frame = z.shape
fx, fy, ft = get_grids(N_X, N_Y, N_frame)
# Normalize the amplitude.
z /= z.max()
from vispy import app, scene, use
try:
AffineTransform = scene.transforms.AffineTransform
except:
AffineTransform = scene.transforms.MatrixTransform
use(app='pyglet', gl='pyopengl2')
#from vispy.util.transforms import perspective, translate, rotate
from vispy.color import Color
transparent = Color(color='black', alpha=0.)
import colorsys
canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=450)
view = canvas.central_widget.add_view()
vol_data = np.rollaxis(np.rollaxis(z, 1), 2)
# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)
center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))
# volume.transform = center
# volume.cmap = 'blues'
if draw_projections:
from vispy.color import Colormap
cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])
opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}
energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)[:, ::-1]
fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)
tr_xy = AffineTransform()
tr_xy.rotate(90, (0, 0, 1))
tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))
fourier_xy.transform = tr_xy
energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]
fourier_xt = scene.visuals.Image(energy_xt, **opts)
tr_xt = AffineTransform()
tr_xt.rotate(90, (1, 0, 0))
tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))
fourier_xt.transform = tr_xt
energy_yt = np.max(z, axis=0)#[:, ::-1]
fourier_yt = scene.visuals.Image(energy_yt, **opts)
tr_yt = AffineTransform()
tr_yt.rotate(90, (0, 1, 0))
tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))
fourier_yt.transform = tr_yt
# Generate iso-surfaces at different energy levels
surfaces = []
for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):
surfaces.append(scene.visuals.Isosurface(z, level=threshold,
# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),
color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),
shading='smooth', parent=view.scene)
)
surfaces[-1].transform = center
# Draw a sphere at the origin
axis = scene.visuals.XYZAxis(parent=view.scene)
for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],
[1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],
[1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):
line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)
axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)
axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)
axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)
if do_axis:
t = {}
for text in ['f_x', 'f_y', 'f_t']:
t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')
t[text].font_size = 8
t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8
t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6
t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2
cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')
cam.fov = 48
cam.scale_factor = N_X * 1.8
if do_axis: margin = 1.35
else: margin = 1
cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))
view.camera = cam
render_im = canvas.render(size=figsize)
app.quit()
if not(name is None):
import vispy.io as io
io.write_png(name + ext, render_im)
else:
return render_im
import os
import numpy as np
import vispy
from vispy import plot as vp
from vispy.color import get_colormap
vispy.use("pyqt5", "gl2")
#create plot widget
fig = vp.Fig(size=(800, 800), show=False)
#generate colors
pairs = ["EUR_CHF", "EUR_USD"]
weeks = [1]
cmap = get_colormap('hsl', value=0.5)
colors = cmap.map(np.linspace(0.1, 0.9, len(pairs)*len(weeks)*2))
j = 0
for pair in pairs:
for week in weeks:
file = pair + "_Week" + str(week)
path = os.path.sep.join(["C:", "fxdata", file + ".csv"])
data = np.genfromtxt(path, skip_header=1, delimiter=",")
for i in [4, 5]:
y = data[:, i]
x = np.arange(0, len(y), 1)
#create line plot
line = fig[0, 0].plot((x, y), width=3, title='~1.6 mill. points', xlabel='Time', ylabel='Price', color=colors[j])
j += 1
# add grid to plot
:copyright: 2020 Precise Simulation Ltd.
"""
try:
import tkinter as tk
except ImportError:
import Tkinter as tk
import tkinter.ttk as ttk
import tkinter.font as tkfont
from tkinter.filedialog import askopenfilename
import vispy
import vispy.scene
# import vispy.visuals
vispy.use(app='tkinter')
import numpy as np
import sys
import os
if os.name == 'nt':
from ctypes import windll, pointer, wintypes
try:
windll.shcore.SetProcessDpiAwareness(1)
except Exception:
pass # this will fail on Windows Server and maybe early Windows
class Model():
def __init__(self, file_name=None):
import os
import numpy as np
from collections import OrderedDict
from matplotlib import cm
from survos2.utils import find_library
if find_library('libOSMesa'):
from vispy import use
use(app='osmesa')
from vispy import app, gloo
from vispy.io import _make_png
from vispy.visuals import ImageVisual, transforms
from vispy.visuals.filters import Alpha
from vispy.color.colormap import Colormap, ColorArray, get_colormaps as get_vispy_cmaps
from survos2.utils import get_logger
from survos2.api.render.backend import Renderer, Layer
BACKEND_NAME = 'Vispy ({})'.format(app.use_app().backend_name)
logger = get_logger()
VispyCmaps = OrderedDict()
VispyCmaps['Primary'] = dict(grays='grays')
VispyCmaps['Others'] = {k: k for k in get_vispy_cmaps() if k != 'grays'}
for cmap_name in ['viridis', 'inferno', 'magma', 'plasma']:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) 2014, Vispy Development Team.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
# -----------------------------------------------------------------------------
import time
from vispy import app, use
from vispy.gloo import clear
use('pyqt4')
# use('glut')
# use('pyglet')
canvas = app.Canvas(size=(512, 512), title = "Do nothing benchmark (vispy)",
close_keys='escape')
@canvas.connect
def on_draw(event):
global t, t0, frames
clear(color=True, depth=True)
t = time.time()
frames = frames + 1
elapsed = (t - t0) # seconds
if elapsed > 2.5:
print("FPS : %.2f (%d frames in %.2f second)"
% (frames / elapsed, frames, elapsed))
t0, frames = t, 0
canvas.update()
def run(sketch_setup=None,
sketch_draw=None,
frame_rate=60,
mode="P2D",
renderer="vispy"):
"""Run a sketch.
if no `sketch_setup` and `sketch_draw` are specified, p5 automatically
"finds" the user-defined setup and draw functions.
:param sketch_setup: The setup function of the sketch (None by
default.)
:type sketch_setup: function
:param sketch_draw: The draw function of the sketch (None by
default.)
:type sketch_draw: function
:param frame_rate: The target frame rate for the sketch.
:type frame_rate: int :math:`\geq 1`
"""
# get the user-defined setup(), draw(), and handler functions.
if sketch_setup is not None:
setup_method = sketch_setup
elif hasattr(__main__, 'setup'):
setup_method = __main__.setup
else:
setup_method = setup
if sketch_draw is not None:
draw_method = sketch_draw
elif hasattr(__main__, 'draw'):
draw_method = __main__.draw
else:
draw_method = draw
handlers = dict()
for handler in handler_names:
if hasattr(__main__, handler):
hfunc = getattr(__main__, handler)
handlers[handler] = _fix_interface(hfunc)
if renderer == "vispy":
import vispy
vispy.use('glfw')
from p5.sketch.Vispy2DRenderer.base import VispySketch
from vispy import app
builtins.current_renderer = "vispy"
if mode == "P2D":
p5.mode = 'P2D'
from p5.sketch.Vispy2DRenderer.renderer2d import VispyRenderer2D
p5.renderer = VispyRenderer2D()
elif mode == "P3D":
p5.mode = 'P3D'
from p5.sketch.Vispy3DRenderer.renderer3d import Renderer3D
p5.renderer = Renderer3D()
else:
ValueError("Invalid Mode %s" % mode)
p5.sketch = VispySketch(setup_method, draw_method, handlers,
frame_rate)
physical_width, physical_height = p5.sketch.physical_size
width, height = p5.sketch.size
builtins.pixel_x_density = physical_width // width
builtins.pixel_y_density = physical_height // height
builtins.start_time = time.perf_counter()
p5.sketch.timer.start()
app.run()
exit()
else:
raise NotImplementedError("Invalid Renderer %s" % renderer)
note whether the layer returned False and is requesting a re-render when the dust has settled => add to dirty layer list
Idle loop
For each dirty layer
Have layer render new draw list
If layer has problems rendering, call a purge on all layers and then re-render
"""
import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *
import vispy
vispy.use(app='PyQt4') #, gl='gl+')
import vispy.scene as vps
from sift.view.MapWidget import SIFTMainMapWidget
class CoordSystem(object):
"""
converts (y,x) pixel coordinates to geodetic coordinates in meters or degrees (lat/lon)
"""
UNKNOWN = 0
DATA_PIXELS = 1 # storage pixels for a given layer
SCREEN_PIXELS = 2 # OpenGL pixels
LATLON_DEGREES = 4 # lat/lon
def get_j_d(day, month, year):
a = int((14 - month) / 12)
b = year + 4800 - a
c = month + 12 * a - 3
return day + int((153 * c + 2) / 5) + 365 * b + int(b / 4) - int(
b / 100) + int(b / 400) - 32045
G = 6.67408e-11 # граивтационная постоянная м3·с−2·кг−1 или Н·м2·кг−2
au = 149597870 # а.е. астрономическая единица
C = 299792458 # скорость света м/с
# настройки окна
vispy.use('PyQt5', 'gl+')
canvas = scene.SceneCanvas(keys='interactive',
title='Planet System',
show=True,
bgcolor='w')
view = canvas.central_widget.add_view()
view.camera = 'turntable'
view.camera.fov = 45
view.camera.distance = 5000000000
axis = scene.visuals.XYZAxis(parent=view.scene)
SUN = Star('Sun', m=1.98892e30) # J2000.0 JD2451545.0
MERCURY = Object('Mercury',
color=(.5, .5, .5, 1),
def plot_sphere(filename,
directions=None,
data=None,
interact=False,
color_norm='linear',
color_min=0,
color_max=4 * np.pi,
gamma=0.25,
color_map='coolwarm',
my_ax=None,
my_cax=None,
dpi=500,
vis_px=1000,
save_file=False):
# Setup viewing window
vispy.use('glfw')
canvas = vispy.scene.SceneCanvas(keys='interactive',
bgcolor='white',
size=(vis_px, vis_px),
show=interact)
my_cam = vispy.scene.cameras.turntable.TurntableCamera(fov=0,
azimuth=135,
scale_factor=2.05)
view = canvas.central_widget.add_view(camera=my_cam)
# Plot dots
dots = vispy.scene.visuals.Markers(parent=view.scene)
dots.antialias = False
dots.set_data(pos=np.array([[1.01, 0, 0], [0, 1.01, 0], [0, 0, 1.01]]),
edge_color='black',
face_color='black',
size=vis_px / 50)
# Calculate colors
if color_norm == 'linear':
norm = matplotlib.colors.Normalize(vmin=color_min, vmax=color_max)
elif color_norm == 'log':
norm = matplotlib.colors.LogNorm(vmin=color_min, vmax=color_max)
elif color_norm == 'linlog':
norm = matplotlib.colors.SymLogNorm(linthresh=1e-3,
vmin=data.min(),
vmax=data.max())
elif color_norm == 'power':
norm = matplotlib.colors.PowerNorm(gamma=gamma,
vmin=data.min(),
vmax=data.max())
norm_data = norm(data).data
norm_data = np.expand_dims(norm_data, 1)
cmap = matplotlib.cm.get_cmap(color_map)
colors = np.apply_along_axis(cmap, 1, norm_data)
# Plot sphere
sphere = visuals.MySphere(parent=view.scene,
radius=1.0,
directions=directions,
colors=colors)
# Display or save
if interact:
visuals.MyXYZAxis(parent=view.scene, origin=[0, 1.3, -0.3], length=0.2)
canvas.app.run()
else:
im = canvas.render()
f = plt.figure(figsize=(5, 5))
local_ax = plt.axes([0.0, 0, 0.9, 0.9]) # x, y, width, height
local_cax = plt.axes([0.95, 0.01, 0.025, 0.86])
if my_ax == None:
my_ax = local_ax
if my_cax == None:
my_cax = local_cax
for (ax, cax) in [(local_ax, local_cax), (my_ax, my_cax)]:
ax.axis('off')
draw_axis(ax)
cmap = ax.imshow(im,
interpolation='none',
cmap=color_map,
norm=norm)
f.colorbar(cmap, cax=cax, orientation='vertical')
# Save
if save_file:
f.savefig(filename, dpi=dpi)
import logging
logging.basicConfig(level=logging.DEBUG)
import xml.etree.ElementTree as ET
import numpy as np
import sys
if True:
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QGridLayout
from PyQt5.QtWidgets import QSpacerItem
from PyQt5.QtCore import QTimer
else:
pass
import vispy
vispy.use(app='PyQT5')
from vispy.plot import Fig
def typed(xml):
"""Convert XML value to Python types"""
type_ = xml.attrib['type']
# The type function may be within brackets
type_func = getattr(__builtins__, type_.strip('[]'))
if type_.startswith('['):
return [type_func(value.strip()) for value in xml.text.split(',')]
else:
return type_func(xml.text.strip())
clog = logging.getLogger('CinfFigure')
class CinfFigure(object):
def run_rm_viz(roi_path, rm_path):
canvas = Canvas(roi_path, rm_path)
vispy.use('PyQt5')
w = MainWindow(canvas)
w.show()
vispy.app.run()
class Application(object):
def __init__(self):
# Create and open the window for user interaction.
self.window = window.TerminalWindow()
# Print some default lines in the terminal as hints.
self.window.log("Operator started the chat.", align="left", color="#808080")
self.window.log("HAL9000 joined.", align="right", color="#808080")
# Construct and initialize the agent for this simulation.
self.agent = HAL9000(self.window)
# Connect the terminal's existing events.
self.window.events.user_input.connect(self.agent.on_input)
self.window.events.user_command.connect(self.agent.on_command)
def run(self):
timer = vispy.app.Timer(interval=1.0)
timer.connect(self.agent.update)
timer.start()
vispy.app.run()
if __name__ == "__main__":
vispy.set_log_level("WARNING")
vispy.use(app="glfw")
app = Application()
app.run()
# -*- coding: utf-8 -*-
"""
"""
import sys
import vispy
vispy.use(app='pyglet', gl=None)
from vispy import app, gloo
from vispy.visuals import CubeVisual, transforms
from vispy.color import Color
from utils.orientation import Orientation
from utils.USB_data import USBData
class Canvas(app.Canvas):
def __init__(self, connection, orientation):
self.con = connection
self.orientation = orientation
app.Canvas.__init__(self, 'Cube', keys='interactive', size=(400, 400))
self.cube = CubeVisual((7.0, 4.0, 0.3),
color=Color(color='grey', alpha=0.1,
clip=False),
edge_color="black")
# Create a TransformSystem that will tell the visual how to draw
self.cube_transform = transforms.MatrixTransform()
self.cube.transform = self.cube_transform
self._timer = app.Timer('0.05', connect=self.on_timer, start=True)
import sys
print(sys.version)
import numpy as np
#import scipy as sci
#import matplotlib
#import lasio
import vispy
vispy.use("pyqt5")
import PyQt5
from PyQt5 import QtWidgets, QtCore, QtGui
from PyQt5.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout
"""
Test the fps capability of Vispy with meshdata primitive
"""
try:
from sip import setapi
setapi("QVariant", 2)
setapi("QString", 2)
except ImportError:
pass
import numpy as np
from vispy import app, gloo
from vispy.util.transforms import perspective, translate, rotate
from vispy.geometry import meshdata as md
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn import metrics
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from vispy import scene, app, use
from sklearn import ensemble
from sklearn import tree
use('PyQt5')
def findNextTick(df, type):
df["nextClose"] = df["High"].shift(-1)
#df["nextTime"] = df["time"].shift(-1)
df["nextIndex"] = df.index
df["nextIndex"] = df["nextIndex"].shift(-1)
df.at[len(df) - 1, 'nextIndex'] = df.iloc[len(df) - 2]["nextIndex"] + 1
df = df[0:len(df) - 2]
#df.to_csv("test3.csv")
X_pred = df[-1:].drop(["nextClose"], axis=1)
print(X_pred)
df = df[0:-1]
X = df.drop(["nextClose"], axis=1)
#X.to_csv("test4.csv")
y = df["nextClose"]
r1 = LinearRegression(n_jobs=-1)
r2 = tree.DecisionTreeRegressor()
r3 = ensemble.RandomForestRegressor(n_jobs=-1)
r4 = ensemble.AdaBoostRegressor()
r5 = ensemble.BaggingRegressor(n_jobs=-1)
# Create and open the window for user interaction.
self.window = window.TerminalWindow()
# Print some default lines in the terminal as hints.
self.window.log('Operator started the chat.', align='left', color='#808080')
self.window.log('HAL9000 joined.', align='right', color='#808080')
# Construct and initialize the agent for this simulation.
self.agent = HAL9000(self.window)
# Connect the terminal's existing events.
self.window.events.user_input.connect(self.agent.on_input)
self.window.events.user_command.connect(self.agent.on_command)
def run(self):
timer = vispy.app.Timer(interval=1.0)
timer.connect(self.agent.update)
timer.start()
vispy.app.run()
self.agent.shutdown()
if __name__ == "__main__":
vispy.set_log_level('WARNING')
vispy.use(app='default')
app = Application()
app.run()
# -*- coding: utf-8 -*-
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
"""
This example shows how to retrieve event information from a callback.
You should see information displayed for any event you triggered.
"""
from vispy import gloo, app, use
use('pyqt4') # can be another app backend name
class Canvas(app.Canvas):
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
self.title = 'App demo'
def on_close(self, event):
print('closing!')
def on_resize(self, event):
print('Resize %r' % (event.size, ))
def on_key_press(self, event):
modifiers = [key.name for key in event.modifiers]
print('Key pressed - text: %r, key: %s, modifiers: %r' % (
event.text, event.key.name, modifiers))
def on_key_release(self, event):
modifiers = [key.name for key in event.modifiers]
def run_complete_viz(aligned_path, roi_path, dff_path):
canvas = Canvas(aligned_path, roi_path, dff_path)
vispy.use('PyQt5')
w = MainWindow(canvas)
w.show()
vispy.app.run()
if os.path.abspath(event.src_path) == self._filename:
print("Updating shader...")
glsl_shader = open(self._filename, 'r').read()
self._canvas.set_shader(glsl_shader)
self._canvas.update()
if __name__ == '__main__':
vispy.set_log_level('WARNING')
# GLFW not part of anaconda python distro; works fine with default (PyQt4)
try:
vispy.use(app='glfw')
except RuntimeError as e:
pass
parser = argparse.ArgumentParser(
description='Render a ShaderToy-style shader from the specified file.')
parser.add_argument('input',
type=str,
help='Source shader file to load from disk.')
parser.add_argument(
'--size',
type=str,
default='1280x720',
help='Width and height of the viewport/output, e.g. 1920x1080 (string).'
)
parser.add_argument(
def run_transparent_cells(aligned_path, roi_path, dff_path):
canvas = Canvas(aligned_path, roi_path, dff_path)
vispy.use('PyQt5')
w = MainWindow(canvas)
w.show()
vispy.app.run()
import imageio
import copy
from networks import Inpaint_Color_Net, Inpaint_Depth_Net, Inpaint_Edge_Net
from MiDaS.run import run_depth
from MiDaS.monodepth_net import MonoDepthNet
from MiDaS import MiDaS_utils
from bilateral_filtering import sparse_bilateral_filtering
parser = argparse.ArgumentParser()
parser.add_argument(
"--config", type=str, default="argument.yml", help="Configure of post processing"
)
args = parser.parse_args()
config = yaml.load(open(args.config, "r"))
if config["offscreen_rendering"] is True:
vispy.use(app="egl")
os.makedirs(config["mesh_folder"], exist_ok=True)
os.makedirs(config["video_folder"], exist_ok=True)
os.makedirs(config["depth_folder"], exist_ok=True)
sample_list = get_MiDaS_samples(
config["src_folder"], config["depth_folder"], config, config["specific"]
)
normal_canvas, all_canvas = None, None
if isinstance(config["gpu_ids"], int) and (config["gpu_ids"] >= 0):
device = config["gpu_ids"]
else:
device = "cpu"
print(f"running on device {device}")
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This example shows how to actively select and test the glfw backend.
You should see a black window and any mouse or keyboard event should be
detected. A timer is also run every second and it should print "tick !"
every second.
"""
from vispy import app, keys, use, gloo
use('glfw')
class Canvas(app.Canvas):
def __init__(self, *args, **kwargs):
app.Canvas.__init__(self, *args, **kwargs)
timer = app.Timer(1.0)
timer.connect(self.on_timer)
timer.start()
def on_initialize(self, event):
gloo.set_clear_color('black')
print('on_initialize')
def on_close(self, event):
print('on_close')
def on_resize(self, event):
print('on_resize (%dx%d)' % event.size)
def __init__(self):
# Create and open the window for user interaction.
self.window = window.TerminalWindow()
# Print some default lines in the terminal as hints.
self.window.log('Operator started the chat.', align='left', color='#808080')
self.window.log('HAL9000 joined.', align='right', color='#808080')
# Construct and initialize the agent for this simulation.
self.agent = HAL9000(self.window)
self.speak = speaker()
# Connect the terminal's existing events.
self.window.events.user_input.connect(self.agent.on_input)
self.window.events.user_command.connect(self.agent.on_command)
def run(self):
timer = vispy.app.Timer(interval=1.0)
timer.start()
self.speak.setDaemon(True)
self.speak.start()
vispy.app.run()
if __name__ == "__main__":
vispy.set_log_level('WARNING')
vispy.use(app='glfw')
app = Application()
app.run()
import imageio
import copy
from networks import Inpaint_Color_Net, Inpaint_Depth_Net, Inpaint_Edge_Net
from MiDaS.run import run_depth
from MiDaS.monodepth_net import MonoDepthNet
import MiDaS.MiDaS_utils as MiDaS_utils
parser = argparse.ArgumentParser()
parser.add_argument('--config',
type=str,
default='argument.yml',
help='Configure of post processing')
args = parser.parse_args()
config = yaml.load(open(args.config, 'r'))
if config['offscreen_rendering'] is True:
vispy.use(app='egl')
os.makedirs(config['mesh_folder'], exist_ok=True)
os.makedirs(config['video_folder'], exist_ok=True)
os.makedirs(config['depth_folder'], exist_ok=True)
sample_list = get_MiDaS_samples(config['src_folder'], config['depth_folder'],
config, config['specific'])
normal_canvas, all_canvas = None, None
if isinstance(config["gpu_ids"], int) and (config["gpu_ids"] >= 0):
device = config["gpu_ids"]
else:
device = "cpu"
for idx in tqdm(range(len(sample_list))):
depth = None
sample = sample_list[idx]
import numpy as np
import sys
from PyQt4.QtGui import (QWidget, QGroupBox, QGridLayout, QLabel,
QSpinBox, QSplitter, QMainWindow, QAction,
QApplication, QVBoxLayout, QHBoxLayout,
qApp, QComboBox)
from PyQt4.QtCore import (pyqtSignal, Qt)
from vispy.color.colormap import get_colormaps
from vispy import scene
from vispy.geometry import create_sphere
from vispy import use
use("PyQt4")
def xyz_to_gp(xyz):
"""
Input X, Y, Z, the Cartesian coordinates of a point
on the unit sphere.
Output, float gamma and phi coordinates of the point.
phi is a longitudinal angle and gamma is a latitudinal
x = np.sin(gamma)*np.cos(phi)
y = np.sin(gamma)*np.sin(phi)
z = np.cos(gamma)
"""
def use_app(backend_name):
"""Use a specific backend."""
CONFIG['VISPY_APP'] = visapp.application.Application(backend_name)
# MPL render :
CONFIG['MPL_RENDER'] = False
# Jupyter / iPython :
try:
ip = get_ipython()
CONFIG['MPL_RENDER'] = True
import vispy
vispy.use('PyQt5')
except NameError:
pass
# Input command line arguments
VISBRAIN_HELP = """
Visbrain command line arguments:
--visbrain-log=(profiler|debug|info|warning|error|critical)
Sets the verbosity of logging output. The default is 'info'.
--visbrain-search=[search string]
Search string in logs.
--visbrain-show=(True|False)
Control if GUI have to be displayed.
def update(self, ev):
canvas.image.set_data(canvas.tensor_data[canvas.i, :, :])
#print(canvas.raw_data[canvas.i,:,:])
print(canvas.i)
canvas.time_text.text = str(canvas.i)
canvas.i += 1
#im=canvas.render()
#self.writer.append_data(im)
if canvas.i >= canvas.raw_data.shape[0]:
#self.writer.close()
#import sys
#sys.exit()
canvas.i = 0
canvas.update()
def change_t_c(self):
canvas.temporal_component = int(self.t_c.text())
canvas.factors_to_tensors()
self.timer_init()
canvas = Canvas()
vispy.use('PyQt5')
w = MainWindow(canvas)
w.show()
vispy.app.run()
#vispy.app.processEvents(
# vispy: testskip
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
"""
This is a simple osmesa example that produce an image of a cube
If you have both osmesa and normal (X) OpenGL installed, execute with
something like the following to pickup the OSMesa libraries::
VISPY_GL_LIB=/opt/osmesa_llvmpipe/lib/libGLESv2.so \
LD_LIBRARY_PATH=/opt/osmesa_llvmpipe/lib/ \
OSMESA_LIBRARY=/opt/osmesa_llvmpipe/lib/libOSMesa.so \
python examples/offscreen/simple_osmesa.py
"""
import vispy
vispy.use(app='osmesa') # noqa
import numpy as np
import vispy.plot as vp
import vispy.io as io
# Check the application correctly picked up osmesa
assert vispy.app.use_app().backend_name == 'osmesa', 'Not using OSMesa'
data = np.load(io.load_data_file('electrophys/iv_curve.npz'))['arr_0']
time = np.arange(0, data.shape[1], 1e-4)
fig = vp.Fig(size=(800, 800), show=False)
x = np.linspace(0, 10, 20)
y = np.cos(x)
