def main():
os.chdir( os.path.dirname( os.path.realpath( __file__ )))
#read the command line arguments or fetch the default values
args=cli_args(sys.argv[2:])
#generate the initial dataset
#TODO collect the "name" of the sample dataset on the command line
sample_dataset,sample_metadata,exec_script=preproc(args)
g=CvuGUI(sample_dataset,sample_metadata,quiet=args['quiet'])
sample_dataset.gui=g
#Qt does not sys.exit in response to KeyboardInterrupt
#we intercept KeyboardInterrupts in the interpreter, before even
#reaching the Qt event loop and force them to call sys.exit
signal.signal(signal.SIGINT, signal.SIG_DFL)
if exec_script is not None:
from pyface.api import GUI
gui=GUI()
def run_script():
gui.process_events()
script(exec_script, cvu_gui=g, scriptdir=sys.argv[1])
gui.invoke_later(run_script)
g.configure_traits()
def visualize(self):
'''
Start the visualisation of the simulation result.
Set up Upgrade method and starts the main loop.
Use only if the simulation result was set!
'''
# update the lookuptables and set them
minL = []
maxL = []
for array in self.scalarSolution[self.solutionPosition][self.scalarPosition].itervalues():
minL.append(array.min())
maxL.append(array.max())
self.SourceMin = min(minL)
self.SourceMax = max(maxL)
for actor in self.vizActors.itervalues():
actor.module_manager.scalar_lut_manager.data_range = [self.SourceMin, self.SourceMax]
#self.vizActors[0].module_manager.scalar_lut_manager.data_name = self.scalarNames[self.solutionPosition][self.scalarPosition]
#self.vizActors[0].module_manager.scalar_lut_manager.show_scalar_bar = True
timer = Timer(0.03, self.update)
gui = GUI()
gui.busy = True
gui.start_event_loop()
def tracking_state_callback(self, sbp_msg, **metadata):
t = time.time() - self.t_init
self.time[0:-1] = self.time[1:]
self.time[-1] = t
# first we loop over all the SIDs / channel keys we have stored and set 0 in for CN0
for key, cno_array in self.CN0_dict.items():
# p
if (cno_array == 0).all():
self.CN0_dict.pop(key)
else:
new_arr = np.roll(cno_array, -1)
new_arr[-1] = 0
self.CN0_dict[key] = new_arr
# If the whole array is 0 we remove it
# for each satellite, we have a (code, prn, channel) keyed dict
# for each SID, an array of size MAX PLOT with the history of CN0's stored
# If there is no CN0 or not tracking for an epoch, 0 will be used
# each array can be plotted against host_time, t
for i, s in enumerate(sbp_msg.states):
if code_is_gps(s.sid.code):
sat = s.sid.sat
elif code_is_glo(s.sid.code):
sat = s.fcn - GLO_FCN_OFFSET
self.glo_slot_dict[sat] = s.sid.sat
key = (s.sid.code, sat, i)
if s.cn0 != 0:
self.CN0_dict[key][-1] = s.cn0 / 4.0
GUI.invoke_later(self.update_plot)
def run(self):
cams, new_cams = register_image(self.vsfm_interface, self.imfn,
match_specified_fn = self.match_specified_fn,
max_sleep_seconds = self.max_sleep_seconds)
GUI.invoke_later(mayaviu.plot_cameras, new_cams)
self.cams = cams
self.new_cams = new_cams
def run(self):
print "Performing expensive calculation in %s..."%self.getName(),
sleep(3)
sd = self.data.scalar_data
sd += numpy.sin(numpy.random.rand(*sd.shape)*2.0*numpy.pi)
GUI.invoke_later(self.data.update)
print 'done.'
def main(argv):
""" A simple example of using the the application scripting framework in a
workbench.
"""
# Create the GUI.
gui = GUI()
# Create the workbench.
workbench = ExampleScript(state_location=gui.state_location)
window = workbench.create_window(position=(300, 300), size=(400, 300))
window.open()
# Create some objects to edit.
# FIXME v3: The need to explicitly set the style to its default value is
# due to a bug in the implementation of Scriptable.
label = Label(text="Label", style='normal')
label2 = Label(text="Label2", style='normal')
# Edit the objects.
window.edit(label)
window.edit(label2)
# Start the GUI event loop.
gui.start_event_loop()
return
def main(argv):
"""A simple example of using the workbench."""
# Create the GUI.
gui = GUI()
# Create the workbench.
#
# fixme: I wouldn't really want to specify the state location here.
# Ideally this would be part of the GUI's as DOMs idea, and the state
# location would be an attribute picked up from the DOM hierarchy. This
# would also be the mechanism for doing 'confirm' etc... Let the request
# bubble up the DOM until somebody handles it.
workbench = ExampleWorkbench(state_location=gui.state_location)
# Create the workbench window.
window = workbench.create_window(position=(300, 300), size=(800, 600))
window.open()
# This will cause a TraitsUI editor to be created.
window.edit(Person(name='fred', age=42, salary=50000))
# This will cause a toolkit specific editor to be created.
window.edit("This text is implemented by a toolkit specific widget.")
# Start the GUI event loop.
gui.start_event_loop()
def select_selected(self, initialized):
""" Force the tree editor to select the current engine selection,
and eventually collapse other scenes.
"""
# We need to explore the editors to find the one we are
# interested in, and to switch its selection to None, and then
# back to what we are interested in.
editors = self.info.ui._editors
if editors is not None:
for editor in editors:
if editor.factory is self.info.object.tree_editor:
tree_editor = editor
break
else:
return
else:
return
# We switch the selection to None, but we avoid
# trait callback, to avoid changing the engine's
# current_selection.
tree_editor.trait_set(selected=None, trait_change_notify=False)
current_selection = self.info.object.engine.current_selection
GUI.set_trait_later(tree_editor, 'selected', current_selection)
# If we are selecting a scene, collapse the others
if isinstance(current_selection, Scene) and \
hasattr(tree_editor._tree, 'Collapse'):
# The wx editor can collapse, dunno for the Qt
for scene in self.info.object.engine.scenes:
if scene is not current_selection:
tree_editor._tree.Collapse(
tree_editor._get_object_nid(scene))
def _baseline_callback_ned(self, sbp_msg, **metadata):
# Updating an ArrayPlotData isn't thread safe (see chaco issue #9), so
# actually perform the update in the UI thread.
if self.running:
#GUI.invoke_later(self.baseline_callback, sbp_msg)
soln = MsgBaselineNED(sbp_msg)
GUI.invoke_later(self.baseline_callback, soln)
cnt = self.cnt % 4
fake_sbp_msg = copy.copy(soln)
if cnt == 3:
fake_sbp_msg.e = 217371
fake_sbp_msg.n = 100837 - (cnt+1) * 10e3
else:
fake_sbp_msg.e = 217371 + cnt * 20e3
fake_sbp_msg.n = 100837 - cnt * 20e3
fake_sbp_msg.sender = 100 + cnt
fake_sbp_msg.flags = cnt
soln = fake_sbp_msg
self.cnt += 1
GUI.invoke_later(self.baseline_callback, soln)
# _threshold_satisfied()函数计算需要优化
# 或者保持数据发送频率小于2(/s)
time.sleep(0.5)
def tracking_state_callback(self, sbp_msg, **metadata):
t = time.time() - self.t_init
self.time[0:-1] = self.time[1:]
self.time[-1] = t
# first we loop over all the SIDs / channel keys we have stored and set 0 in for CN0
for key, cno_array in self.CN0_dict.items():
# p
if (cno_array==0).all():
self.CN0_dict.pop(key)
else:
self.CN0_dict[key][0:-1] = cno_array[1:]
self.CN0_dict[key][-1] = 0
# If the whole array is 0 we remove it
# for each satellite, we have a (code, prn, channel) keyed dict
# for each SID, an array of size MAX PLOT with the history of CN0's stored
# If there is no CN0 or not tracking for an epoch, 0 will be used
# each array can be plotted against host_time, t
for i,s in enumerate(sbp_msg.states):
prn = s.sid.sat
if code_is_gps(s.sid.code):
prn += 1
key = (s.sid.code, prn, i)
if s.state != 0:
if len(self.CN0_dict.get(key, [])) == 0:
self.CN0_dict[key] = np.zeros(NUM_POINTS)
self.CN0_dict[key][-1] = s.cn0
GUI.invoke_later(self.update_plot)
def manage_multi_firmware_update(self):
# Set up progress dialog and transfer file to Piksi using SBP FileIO
progress_dialog = PulsableProgressDialog(len(self.stm_fw.blob))
progress_dialog.title = "Transferring image file"
GUI.invoke_later(progress_dialog.open)
self._write("Transferring image file...")
try:
FileIO(self.link).write("upgrade.image_set.bin", self.stm_fw.blob,
progress_cb=progress_dialog.progress)
except Exception as e:
self._write("Failed to transfer image file to Piksi: %s\n" % e)
progress_dialog.close()
return
try:
progress_dialog.close()
except AttributeError:
pass
# Setup up pulsed progress dialog and commit to flash
progress_dialog = PulsableProgressDialog(100, True)
progress_dialog.title = "Committing to flash"
GUI.invoke_later(progress_dialog.open)
self._write("Committing file to flash...")
def log_cb(msg, **kwargs): self._write(msg.text)
self.link.add_callback(log_cb, SBP_MSG_LOG)
code = shell_command(self.link, "upgrade_tool upgrade.image_set.bin", 240)
self.link.remove_callback(log_cb, SBP_MSG_LOG)
progress_dialog.close()
if code != 0:
self._write('Failed to perform upgrade (code = %d)' % code)
return
self._write('Resetting Piksi...')
self.link(MsgReset(flags=0))
def manage_nap_firmware_update(self, check_version=False):
# Flash NAP if out of date.
try:
local_nap_version = parse_version(
self.settings['system_info']['nap_version'].value)
remote_nap_version = parse_version(self.newest_nap_vers)
nap_out_of_date = local_nap_version != remote_nap_version
except KeyError:
nap_out_of_date = True
if nap_out_of_date or check_version==False:
text = "Updating NAP"
self._write(text)
self.create_flash("M25")
nap_n_ops = self.pk_flash.ihx_n_ops(self.nap_fw.ihx)
progress_dialog = PulsableProgressDialog(nap_n_ops, True)
progress_dialog.title = text
GUI.invoke_later(progress_dialog.open)
self.pk_flash.write_ihx(self.nap_fw.ihx, self.stream, mod_print=0x40, \
elapsed_ops_cb = progress_dialog.progress)
self.stop_flash()
self._write("")
progress_dialog.close()
return True
else:
text = "NAP is already to latest version, not updating!"
self._write(text)
self._write("")
return False
def process(self):
for job in self.jobs:
job.percent_complete = min(
job.percent_complete + random.randint(0, 3), 100)
if any(job.percent_complete < 100 for job in self.jobs):
GUI.invoke_after(100, self.process)
def test_coreg_gui():
"""Test CoregFrame."""
_check_ci()
home_dir = _TempDir()
os.environ['_MNE_GUI_TESTING_MODE'] = 'true'
os.environ['_MNE_FAKE_HOME_DIR'] = home_dir
try:
assert_raises(ValueError, mne.gui.coregistration, subject='Elvis',
subjects_dir=subjects_dir)
from pyface.api import GUI
gui = GUI()
# avoid modal dialog if SUBJECTS_DIR is set to a directory that
# does not contain valid subjects
ui, frame = mne.gui.coregistration(subjects_dir='')
frame.model.mri.subjects_dir = subjects_dir
frame.model.mri.subject = 'sample'
assert_false(frame.model.mri.fid_ok)
frame.model.mri.lpa = [[-0.06, 0, 0]]
frame.model.mri.nasion = [[0, 0.05, 0]]
frame.model.mri.rpa = [[0.08, 0, 0]]
assert_true(frame.model.mri.fid_ok)
frame.raw_src.file = raw_path
# grow hair (high-res head has no norms)
assert_true(frame.model.mri.use_high_res_head)
frame.model.mri.use_high_res_head = False
frame.model.grow_hair = 40.
# scale
frame.coreg_panel.n_scale_params = 3
frame.coreg_panel.scale_x_inc = True
assert_equal(frame.model.scale_x, 1.01)
frame.coreg_panel.scale_y_dec = True
assert_equal(frame.model.scale_y, 0.99)
# reset parameters
frame.coreg_panel.reset_params = True
assert_equal(frame.model.grow_hair, 0)
assert_false(frame.model.mri.use_high_res_head)
# configuration persistence
assert_true(frame.model.prepare_bem_model)
frame.model.prepare_bem_model = False
frame.save_config(home_dir)
ui.dispose()
gui.process_events()
ui, frame = mne.gui.coregistration(subjects_dir=subjects_dir)
assert_false(frame.model.prepare_bem_model)
assert_false(frame.model.mri.use_high_res_head)
ui.dispose()
gui.process_events()
finally:
del os.environ['_MNE_GUI_TESTING_MODE']
del os.environ['_MNE_FAKE_HOME_DIR']
def _append_log(self, msg, endline="\n"):
def toappend():
if self._progress_started:
self._progress_logs += msg + endline
else:
self._logs += msg + endline
GUI.invoke_later(toappend) # to be thread safe when logs are displayed in gui
def main():
# Create the GUI.
gui = GUI()
# Create and open an application window.
window = IVTKWithCrustAndBrowser(size=(800,600))
window.open()
# Start the GUI event loop!
gui.start_event_loop()
def _wrap_update():
update_funcs = self._update_funcs.copy()
self._update_funcs.clear()
for update in update_funcs.values():
update_func, args = update
update_func(*args)
if self._update_funcs:
GUI.invoke_later(_wrap_update)
def close():
"""Close the scene."""
f = mlab.gcf()
e = mlab.get_engine()
e.window.workbench.prompt_on_exit = False
e.window.close()
mlab.options.backend = 'auto'
# Hack: on Linux the splash screen does not go away so we force it.
GUI.invoke_after(500, e.window.workbench.application.gui.stop_event_loop)
def _make_active(self, obj):
"""Make the object given, `obj`, the current selection of the
engine."""
engine = get_engine(obj)
if engine is not None:
# This is required when running mayavi in envisage.
GUI.set_trait_later(engine, 'current_selection', obj)
else:
print "No engine"
def set_view(self, s):
"""Sets the view correctly."""
#s.scene.reset_zoom()
s.scene.z_plus_view()
c = s.scene.camera
c.azimuth(30)
c.elevation(30)
s.render()
GUI.process_events()
def lock_orientation(obj, name, old, new):
## print 'locking o'
if orientation_flag[obj]:
orientation_flag[obj] = False
return
def icb():
orientation_flag[obj] = True
obj.orientation = np.array(old)
GUI.invoke_later(icb)
def run(self):
step = 0
while (self.running):
self.interface.datamodel.Update()
step += 1
if step>=self.interface.steps:
step=0
GUI.invoke_later(self.interface.callback)
GUI.invoke_later(self.interface.redraw_scene)
def lock_scale(obj, name, old, new):
## print 'locking s'
if scale_flag[obj]:
scale_flag[obj] = False
return
## if np.all(new==1): return
def icb():
scale_flag[obj] = True
obj.scale = np.array(old)
GUI.invoke_later(icb)
def close(self):
""" Close the dialog. """
self._closing = True
# We don't call our superclass' 'close' method immediately as there
# may be one final call to '_pulse_and_reschedule' already on the
# event queue. This makes sure that we call 'close' *after* that final
# update.
GUI.invoke_after(self.delay, super(PulseProgressDialog, self).close)
def _run(self):
GUI.invoke_later(self.edit_traits, self.view)
while not self.handler_executed:
sleep(0.1)
if self.execute_callback:
GUI.invoke_later(self.callback)
if not self.closed:
self.close = 1
def main():
# Create the GUI.
gui = GUI()
# Create and open the main window.
window = MainWindow()
window.open()
# Start the GUI event loop!
gui.start_event_loop()
def lock_position(obj, name, old, new):
## print 'locking p'
if position_flag[obj]:
position_flag[obj] = False
return
## if np.all(new==0): return
def icb():
position_flag[obj] = True
"""crash seems to originate here? lost as to why"""
obj.position = np.array(old)
## obj.position = 0,0,0
GUI.invoke_later(icb)
def close_scene(self, scene):
"""Given a VTK scene instance, this method closes it.
"""
active_window = self.window
s = scene.scene
for editor in active_window.editors[:]:
if isinstance(editor, scene_editor.SceneEditor):
if id(editor.scene) == id(s):
editor.close()
break
# Flush the UI.
GUI.process_events()
def new_scene(self):
"""Creates a new TVTK scene, sets its size to that prescribed
and returns the scene.
"""
script = self.script
# Create a new VTK scene.
script.new_scene()
# Set its background.
if self.standalone:
GUI.process_events()
s = script.engine.current_scene
s.scene.background = (0.5, 0.5, 0.5)
return s
def _loaded_changed(self, value):
if value:
n = self.dname
if ' [Active]' not in n:
self.dname = "%s [Loaded]" % n
if not self.window is None:
#from pyface.timer.api import do_later
from pyface.api import GUI
GUI.invoke_later(self.window.status_bar_manager.set, message = '')
else:
self.dname = self.dname.replace(' [Loaded]', '')
def spectrum_analyzer_state_callback(self, sbp_msg, **metadata):
'''
Params
======
sbp_msg: sbp.msg.SBP object
Updates the view's data for use in self.update_plot
'''
self.fftmonitor.capture_fft(sbp_msg, **metadata)
channel = int(self.which_plot[-1:])
if self.fftmonitor.num_ffts(channel) > 0:
most_recent_fft = self.fftmonitor.get_ffts(channel).pop()
self.fftmonitor.clear_ffts()
self.most_recent_complete_data['frequencies'] = most_recent_fft[
'frequencies']
self.most_recent_complete_data['amplitudes'] = most_recent_fft[
'amplitudes']
GUI.invoke_later(self.update_plot)
def main(argv):
""" A simple example of using Tasks.
"""
# Create the GUI (this does NOT start the GUI event loop).
gui = GUI()
# Create a Task and add it to a TaskWindow.
task1 = ExampleTask()
task2 = SecondTask()
window = TaskWindow(size=(800, 600))
window.add_task(task1)
window.add_task(task2)
# Show the window.
window.open()
# Start the GUI event loop.
gui.start_event_loop()
def force_draw(self):
r"""
Method for forcing the current figure to render. This is useful for
the widgets animation.
"""
from pyface.api import GUI
_gui = GUI()
orig_val = _gui.busy
_gui.set_busy(busy=True)
_gui.set_busy(busy=orig_val)
_gui.process_events()
def manage_stm_firmware_update(self):
# Erase all of STM's flash (other than bootloader) if box is checked.
if self.erase_stm:
text = "Erasing STM"
self._write(text)
self.create_flash("STM")
sectors_to_erase = set(range(self.pk_flash.n_sectors)).difference(
set(self.pk_flash.restricted_sectors))
progress_dialog = PulsableProgressDialog(len(sectors_to_erase),
False)
progress_dialog.title = text
GUI.invoke_later(progress_dialog.open)
erase_count = 0
for s in sorted(sectors_to_erase):
progress_dialog.progress(erase_count)
self._write('Erasing %s sector %d' %
(self.pk_flash.flash_type, s))
self.pk_flash.erase_sector(s)
erase_count += 1
self.stop_flash()
self._write("")
try:
progress_dialog.close()
except AttributeError:
pass
# Flash STM.
text = "Updating STM"
self._write(text)
self.create_flash("STM")
stm_n_ops = self.pk_flash.ihx_n_ops(self.stm_fw.ihx, \
erase = not self.erase_stm)
progress_dialog = PulsableProgressDialog(stm_n_ops, True)
progress_dialog.title = text
GUI.invoke_later(progress_dialog.open)
# Don't erase sectors if we've already done so above.
self.pk_flash.write_ihx(self.stm_fw.ihx, self.stream, mod_print=0x40, \
elapsed_ops_cb = progress_dialog.progress, \
erase = not self.erase_stm)
self.stop_flash()
self._write("")
try:
progress_dialog.close()
except AttributeError:
pass
def _take_3d_screenshot(figure, mode='rgb', filename=None):
from mayavi import mlab
from mne.viz.backends.renderer import MNE_3D_BACKEND_TESTING
if MNE_3D_BACKEND_TESTING:
ndim = 3 if mode == 'rgb' else 4
if figure.scene is None:
figure_size = (600, 600)
else:
figure_size = figure.scene._renwin.size
return np.zeros(tuple(figure_size) + (ndim,), np.uint8)
else:
from pyface.api import GUI
gui = GUI()
gui.process_events()
with warnings.catch_warnings(record=True): # traits
img = mlab.screenshot(figure, mode=mode)
if isinstance(filename, str):
_save_figure(img, filename)
return img
def manage_multi_firmware_update(self):
# Set up progress dialog and transfer file to Piksi using SBP FileIO
progress_dialog = PulsableProgressDialog(len(self.stm_fw.blob))
progress_dialog.title = "Transferring image file"
GUI.invoke_later(progress_dialog.open)
self._write("Transferring image file...")
try:
FileIO(self.link).write("upgrade.image_set.bin",
self.stm_fw.blob,
progress_cb=progress_dialog.progress)
except Exception as e:
self._write("Failed to transfer image file to Piksi: %s\n" % e)
progress_dialog.close()
return
try:
progress_dialog.close()
except AttributeError:
pass
# Setup up pulsed progress dialog and commit to flash
progress_dialog = PulsableProgressDialog(100, True)
progress_dialog.title = "Committing to flash"
GUI.invoke_later(progress_dialog.open)
self._write("Committing file to flash...")
def log_cb(msg, **kwargs):
self._write(msg.text)
self.link.add_callback(log_cb, SBP_MSG_LOG)
code = shell_command(self.link,
"upgrade_tool upgrade.image_set.bin",
600,
progress_cb=progress_dialog.progress)
self.link.remove_callback(log_cb, SBP_MSG_LOG)
progress_dialog.close()
if code != 0:
self._write('Failed to perform upgrade (code = %d)' % code)
if code == -255:
self._write('Shell command timed out. Please try again.')
return
self._write('Resetting Piksi...')
self.link(MsgReset(flags=0))
def test7(self):
s = tvtk.STLReader(file_name="E:/mesh.stl") # 调用stl文件
m = tvtk.PolyDataMapper(input_connection=s.output_port)
a = tvtk.Actor(mapper=m)
# win=ivtk.IVTKWithCrust()
# win=ivtk.IVTK()
win = ivtk.IVTKWithCrustAndBrowser()
win.open()
win.scene.add_actor(a)
win.scene.isometric_view()
dialog = win.control.centralWidget().widget(0).widget(0)
from pyface.qt import QtCore
dialog.setWindowFlags(QtCore.Qt.WindowFlags(0x00000000))
dialog.show()
gui = GUI()
gui.start_event_loop()
def _on_editor_closed(self, editor):
""" Dynamic trait change handler. """
index = self.editors.index(editor)
del self.editors[index]
if editor is self.active_editor:
if len(self.editors) > 0:
index = min(index, len(self.editors) - 1)
# If the user closed the editor manually then this method is
# being called from a toolkit-specific event handler. Because
# of that we have to make sure that we don't change the focus
# from within this method directly hence we activate the editor
# later in the GUI thread.
GUI.invoke_later(self.activate_editor, self.editors[index])
else:
self.active_editor = None
return
def settings_display_setup(self, do_read_finished=True):
self.settings_list = []
sections = sorted(self.settings.keys())
for sec in sections:
this_section = []
for name, setting in sorted(self.settings[sec].iteritems(),
key=lambda (n, s): s.ordering):
if not setting.expert or (self.expert and setting.expert):
this_section.append(setting)
if this_section:
self.settings_list.append(SectionHeading(sec))
self.settings_list += this_section
# call read_finished_functions as needed
if do_read_finished:
for cb in self.read_finished_functions:
if self.gui_mode:
GUI.invoke_later(cb)
else:
cb()
def main(argv):
""" A simple example of using the the undo framework in a workbench. """
# Create the GUI.
gui = GUI()
# Create the workbench.
workbench = ApplicationWorkbench(state_location=gui.state_location)
window = workbench.create_window(position=(300, 300), size=(400, 300))
window.open()
# fixme: This is a little silly...
window.edit(workbench.app.project.active_experiment)
# Start the GUI event loop.
gui.start_event_loop()
return
def main():
gui = GUI()
# Create and open an application window.
window = ivtk.IVTKWithCrustAndBrowser(size=(800, 600))
window.open()
f = Figure(window.scene)
# Create an outline.
o = Outline()
f.add(o)
# Create some pretty pictures.
#test_lines(f)
test_surf(f)
window.scene.reset_zoom()
# Start the GUI event loop!
gui.start_event_loop()
def require_gui(func):
""" Decorator for tests that require a non-null GUI toolkit.
"""
# Defer GUI import side-effect.
# The toolkit is not resolved until we import pyface.api
from pyface.api import GUI
try:
GUI()
except NotImplementedError:
return unittest.skip("No GUI available.")(func)
return func
def progress(self, count):
"""
Update progress of progress bar. If pulsing initially, wait until count
is at least 12 before changing to discrete progress bar.
Parameters
----------
count : int
Current value of progress.
"""
# Provide user feedback initially via pulse for slow sector erases.
if self.pulsed:
if count > 12:
self.max = 100
GUI.invoke_later(self.update,
int(100 * float(count) / self.passed_max))
else:
self.max = 100
GUI.invoke_later(self.update,
int(100 * float(count) / self.passed_max))
def schedule_update(self, ident, update_func, *args):
'''Schedule a GUI update'''
def _wrap_update():
self._lock.acquire()
update_funcs = self._update_funcs.copy()
self._update_funcs.clear()
self._lock.release()
for update in update_funcs.values():
update_func, args = update
update_func(*args)
if self._update_funcs:
GUI.invoke_later(_wrap_update)
self._lock.acquire()
if self._update_funcs:
self._update_funcs[ident] = (update_func, args)
else:
self._update_funcs[ident] = (update_func, args)
GUI.invoke_later(_wrap_update)
self._lock.release()
def test_event_processed_prior_to_resolving_location(self):
# Test GUI events are processed prior to resolving location
gui = GUI()
model = NumberHasTraits()
gui.set_trait_later(model, "number", 2)
def solver(wrapper, location):
return model.number
wrapper = example_ui_wrapper(
registries=[
StubRegistry(
solver=solver,
supported_locator_classes=[float],
)
],
)
new_wrapper = wrapper.locate(4.567)
self.assertEqual(new_wrapper._target, 2)
def run(self):
while True:
frame = self.queue.get() # blocks until a frame is available
if self.abort_flag:
break
if self.queue.qsize() > 2:
continue # drop frame if there is a backlog
# Do any transformations on the frame
for plugin in self.controller.transform_plugins:
frame = plugin.process_frame(frame)
# Display the frame on screen
GUI.set_trait_later(self.controller.screen, 'data', frame)
# Send the frame to the analysis components
for plugin in self.controller.display_plugins:
plugin.process_frame(frame)
time.sleep(1.0 / self.update_frequency)
def main(argv):
""" A simple example of using the workbench. """
# Create the GUI (this does NOT start the GUI event loop).
gui = GUI()
# Create some objects to edit.
fred = Person(name="fred", age=42)
wilma = Person(name="wilma", age=35)
# Create the workbench.
#
# fixme: I wouldn't really want to specify the state location here.
# Ideally this would be part of the GUI's as DOMs idea, and the state
# location would be an attribute picked up from the DOM hierarchy. This
# would also be the mechanism for doing 'confirm' etc... Let the request
# bubble up the DOM until somebody handles it.
workbench = ExampleWorkbench(state_location=gui.state_location)
# Create some workbench windows.
x = 300
y = 300
for i in range(2):
window = workbench.create_window(position=(x, y), size=(800, 600))
window.open()
# Edit the objects if they weren't restored from a previous session.
if window.get_editor_by_id("fred") is None:
window.edit(fred)
if window.get_editor_by_id("wilma") is None:
window.edit(wilma)
# Cascade the windows.
x += 100
y += 100
# Start the GUI event loop.
gui.start_event_loop()
return
def create_control(self, parent):
""" Creates the toolkit-specific control that represents the view. """
self.shell = IPythonWidget(parent,
banner='\n'.join(self._banner),
interp=self.interpreter)
# Namespace contributions.
for bindings in self._bindings:
for name, value in bindings.items():
self.bind(name, value)
for command in self._commands:
try:
self.execute_command(command)
except Exception as e:
logger.exception(
"The command '%s' supplied to the Ipython shell "
"plugin has raised an exception:\n%s" %
(command, traceback.format_exc()))
# Register the view as a service.
self.window.application.register_service(IPythonShell, self)
ns_view = self.window.application.get_service(INamespaceView)
if ns_view is not None:
self.on_trait_change(ns_view._on_names_changed, 'names')
def try_set_focus():
try:
self.shell.control.SetFocus()
except:
# The window may not have been created yet.
pass
def set_focus():
self.window.application.gui.invoke_later(try_set_focus)
GUI.invoke_later(set_focus)
return self.shell.control
def test_tree_editor_with_nested_ui(self):
tree_editor = TreeEditor(
nodes=[
TreeNode(
node_for=[Bogus],
auto_open=True,
children="bogus_list",
label="bogus",
view=View(Item("name")),
),
],
hide_root=True,
)
bogus_list = [Bogus()]
object_view = BogusTreeView(bogus=Bogus(bogus_list=bogus_list))
view = View(Item("bogus", id="tree", editor=tree_editor))
with reraise_exceptions(), \
create_ui(object_view, dict(view=view)) as ui:
editor = ui.info.tree
editor.selected = bogus_list[0]
GUI.process_events()
def tracking_state_callback(self, data):
n_channels = len(data) / TRACKING_STATE_BYTES_PER_CHANNEL
if n_channels != self.n_channels:
# Update number of channels
self.n_channels = n_channels
self.states = [TrackingState(0, 0, 0) for _ in range(n_channels)]
for pl in self.plot.plots.iterkeys():
self.plot.delplot(pl.name)
self.plots = []
for n in range(n_channels):
self.plot_data.set_data('ch'+str(n), [0.0])
pl = self.plot.plot(('t', 'ch'+str(n)), type='line', color='auto', name='ch'+str(n))
self.plots.append(pl)
print 'Number of tracking channels changed to', n_channels
fmt = '<' + n_channels * 'BBf'
state_data = struct.unpack(fmt, data)
for n, s in enumerate(self.states):
s.update(*state_data[3*n:3*(n+1)])
GUI.invoke_later(self.update_plot)
def _anytrait_changed(self, name, old, new):
if name[:4] == 'var_':
name = name[4:]
if (not self._no_block_update) and (self.block is not None):
if isinstance(old, ArangeGenerator):
old.on_trait_change(self._array_changed,
'array',
remove=True)
if isinstance(new, ArangeGenerator):
new.on_trait_change(self._array_changed, 'array')
new = new.array
self.context[name] = new
self._needs_update = True
#print "Adding update func"
def update_func():
if self._needs_update:
self._blocks[name].execute(self.context)
self._needs_update = False
GUI.invoke_after(10, update_func)
def step10(self):
theoretical = np.genfromtxt(f"{TestDataPath}/PyMieScattQscaCoreShellMedium.csv", delimiter=',')
Diameter = np.geomspace(10e-9, 500e-9, 400)
scatSet = CoreShellSet(CoreDiameter = Diameter, ShellDiameter = 600e-9, CoreIndex = 1.4, ShellIndex=1.5, nMedium = 1.2)
sourceSet = SourceSet(Wavelength = 600e-9, Polarization = [None], Amplitude = 1)
ExpSet = Setup(ScattererSet = scatSet, SourceSet = sourceSet, DetectorSet = None)
Data = ExpSet.Get(Measure.Qsca).Data.squeeze()
GUI.invoke_after(PLOTTIME, Close)
plt.figure()
plt.plot(Diameter, Data,'C1-', linewidth=3, label='PyMieSim' )
plt.plot( Diameter, theoretical,'k--', linewidth=1, label='PyMieScatt')
plt.xlabel(r'Diameter [\mu m]'); plt.ylabel('Scattering efficiency [CoreShell + nMedium]')
plt.grid(); plt.legend(); plt.tight_layout()
plt.show()
if not np.all(np.isclose(Data,theoretical, 1e-9)):
raise
def demo_main(cls, **traits):
""" Create the demo application and start the mainloop, if needed
This should be called with appropriate arguments which will be passed
to the class' constructor.
"""
# get the Pyface GUI
gui = GUI()
# create the application's main window
window = cls(**traits)
window.open()
# start the application
# if there isn't already a running mainloop, this will block
gui.start_event_loop()
# if there is already a running mainloop (eg. in an IPython session),
# return a reference to the window so that our caller can hold on to it
return window
def test_locate_event_processed_optional(self):
# Allow event processing to be switched off.
gui = GUI()
side_effect = mock.Mock()
gui.invoke_later(side_effect)
self.addCleanup(process_cascade_events)
def solver(wrapper, location):
return 1
wrapper = example_ui_wrapper(
registries=[StubRegistry(solver=solver)],
auto_process_events=False,
)
# With auto_process_events set to False, events are not automatically
# processed.
new_wrapper = wrapper.locate(None)
self.assertEqual(side_effect.call_count, 0)
self.assertFalse(new_wrapper._auto_process_events)
def run_mlab_examples():
from mayavi import mlab
from mayavi.tools.animator import Animator
############################################################
# run all the "test_foobar" functions in the mlab module.
for name, func in getmembers(mlab):
if not callable(func) or not name[:4] in ('test', 'Test'):
continue
if sys.platform == 'win32' and name == 'test_mesh_mask_custom_colors':
# fixme: This test does not seem to work on win32, disabling for now.
continue
mlab.clf()
GUI.process_events()
obj = func()
if isinstance(obj, Animator):
obj.delay = 10
# Close the animation window.
obj.close()
while is_timer_running(obj.timer):
GUI.process_events()
sleep(0.05)
# Mayavi has become too fast: the operator cannot see if the
# Test function was succesful.
GUI.process_events()
sleep(0.1)
def test_error_from_gui_captured_and_raise(self):
def raise_error_1():
raise ZeroDivisionError()
def raise_error_2():
raise IndexError()
# without the context manager:
# - with Qt5, the test run will be aborted prematurely.
# - with Qt4, the traceback is printed and the test passes.
# - with Wx, the traceback is printed and the test passes.
# With the context manager, the exception is always reraised.
gui = GUI()
with self.assertRaises(RuntimeError) as exception_context, \
self.assertLogs("traitsui") as watcher:
with reraise_exceptions():
gui.invoke_later(raise_error_1)
gui.invoke_later(raise_error_2)
gui.process_events()
error_msg = str(exception_context.exception)
self.assertIn("ZeroDivisionError", error_msg)
self.assertIn("IndexError", error_msg)
log_content1, log_content2 = watcher.output
self.assertIn("ZeroDivisionError", log_content1)
self.assertIn("IndexError", log_content2)
def test_dispose_inner_ui(self):
obj = DummyObject()
view = View(
Group(
Item(
"number",
editor=BasicEditorFactory(klass=EditorWithCustomWidget),
), ), )
ui = obj.edit_traits(view=view)
editor, = ui.get_editors("number")
gui = GUI()
with ensure_destroyed(ui):
# This represents an event handler that causes a nested UI to be
# disposed.
gui.invoke_later(editor.dispose_inner_ui)
# Allowing GUI to process the disposal requests is crucial.
# This requirement should be satisfied in production setting
# where the dispose method is part of an event handler.
# Not doing so before disposing the main UI would be a programming
# error in tests settings.
with reraise_exceptions():
process_cascade_events()
gui.invoke_later(close_control, ui.control)
with reraise_exceptions():
process_cascade_events()
self.assertIsNone(ui.control)
class SimpleApplication(HasStrictTraits):
"""
Simple application that attempts to set a trait at start time,
and immediately exits in response to that trait.
"""
# The GUI instance underlying this app.
gui = Instance(IGUI)
# Event fired after the event loop starts.
application_running = Event
def __init__(self):
super(HasStrictTraits, self).__init__()
self.gui = GUI()
def start(self):
"""
Start the application.
"""
# This shouldn't be executed until after the event loop is running.
self.gui.set_trait_later(self, 'application_running', True)
self.gui.start_event_loop()
def stop(self):
self.gui.stop_event_loop()
def tracking_state_callback(self, sbp_msg, **metadata):
n_channels = len(sbp_msg.states)
if n_channels != self.n_channels:
# Update number of channels
self.n_channels = n_channels
self.states = [TrackingState(0, 0, 0, 0) for _ in range(n_channels)]
for pl in self.plot.plots.iterkeys():
self.plot.delplot(pl.name)
self.plots = []
for n in range(n_channels):
self.plot_data.set_data('ch' + str(n), [0.0])
pl = self.plot.plot(('t', 'ch' + str(n)), type='line', color='auto',
name='ch' + str(n))
self.plots.append(pl)
print 'Number of tracking channels changed to {0}'.format(n_channels)
for n, k in enumerate(self.states):
s = sbp_msg.states[n]
prn = s.sid.sat
if (s.sid.code == 0 or s.sid.code == 1):
prn += 1
k.update(s.state, prn, s.cn0, s.sid.code)
GUI.invoke_later(self.update_plot)
def test_event_processed(self):
# Test GUI events are processed such that the trait is changed.
gui = GUI()
model = NumberHasTraits()
def handler(wrapper, action):
gui.set_trait_later(model, "number", 2)
wrapper = example_ui_wrapper(
registries=[StubRegistry(handler=handler)], )
with self.assertTraitChanges(model, "number"):
wrapper.perform(None)
