def test_change_components():
# Regression test for a bug that caused table viewers to not update when
# adding/removing components. For now, this does not work with Qt 5.7.
app = get_qapp() # noqa
d = Data(a=[1, 2, 3, 4, 5],
b=[3.2, 1.2, 4.5, 3.3, 2.2],
c=['e', 'b', 'c', 'a', 'f'],
label='test')
dc = DataCollection([d])
gapp = GlueApplication(dc)
viewer = gapp.new_data_viewer(TableViewer)
viewer.add_data(d)
data_changed = MagicMock()
viewer.model.dataChanged.connect(data_changed)
# layoutChanged needs to be emitted for the new/removed columns to be
# registered (dataChanged is not enough)
layout_changed = MagicMock()
viewer.model.layoutChanged.connect(layout_changed)
assert data_changed.call_count == 0
assert layout_changed.call_count == 0
viewer.model.columnCount() == 2
d.add_component([3, 4, 5, 6, 2], 'z')
assert data_changed.call_count == 1
assert layout_changed.call_count == 1
viewer.model.columnCount() == 3
d.remove_component(d.id['z'])
assert data_changed.call_count == 2
assert layout_changed.call_count == 2
viewer.model.columnCount() == 2
def test_add_viewer(self, tmpdir):
d1 = Data(x=np.random.random((2, ) * self.ndim))
d2 = Data(x=np.random.random((2, ) * self.ndim))
dc = DataCollection([d1, d2])
app = GlueApplication(dc)
w = app.new_data_viewer(self.widget_cls, data=d1)
w.viewer_size = (300, 400)
filename = tmpdir.join('session.glu').strpath
app.save_session(filename, include_data=True)
app2 = GlueApplication.restore_session(filename)
# test session is restored correctly
for viewer in app2.viewers:
assert viewer[0].viewer_size == (300, 400)
app.close()
app2.close()
def setup_method(self, method):
self.data = Data(label='d1')
self.data.coords = SimpleCoordinates()
self.data['x'] = np.arange(240).reshape((30, 4, 2)).astype(float)
self.app = GlueApplication()
self.session = self.app.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.app.new_data_viewer(ProfileViewer)
self.viewer.state.function = 'mean'
self.viewer.toolbar.active_tool = 'profile-analysis'
self.profile_tools = self.viewer.toolbar.tools[
'profile-analysis']._profile_tools
def setup_method(self, method):
LinkSame = core.link_helpers.LinkSame
d = core.Data(label='im', x=[[1, 2], [2, 3]], y=[[2, 3], [4, 5]])
d2 = core.Data(label='cat',
x=[0, 1, 0, 1],
y=[0, 0, 1, 1],
z=[1, 2, 3, 4])
dc = core.DataCollection([d, d2])
dc.add_link(LinkSame(d.get_pixel_component_id(0), d2.id['x']))
dc.add_link(LinkSame(d.get_pixel_component_id(1), d2.id['y']))
app = GlueApplication(dc)
w = app.new_data_viewer(ImageWidget, data=d)
self.d = d
self.app = app
self.w = w
self.d2 = d2
self.dc = dc
def qglue():
"""
Quickly send python variables to Glue for visualization.
Returns
-------
ga : ``GlueApplication`` object
"""
from glue.core import DataCollection
from glue.app.qt import GlueApplication
dc = DataCollection()
# Suppress pesky Glue warnings.
with warnings.catch_warnings():
warnings.simplefilter('ignore', GlueDeprecationWarning)
ga = GlueApplication(data_collection=dc, maximized=False)
return ga
def test_options_widget(self):
d1 = Data(x=np.random.random((2, ) * self.ndim))
d2 = Data(x=np.random.random((2, ) * self.ndim))
dc = DataCollection([d1, d2])
app = GlueApplication(dc)
w = app.new_data_viewer(self.widget_cls, data=d1)
w.state.x_stretch = 0.5
w.state.y_stretch = 1.0
w.state.z_stretch = 2.0
w.state.x_min = -0.1
w.state.x_max = 10.1
w.state.y_min = 0.1
w.state.y_max = 10.9
w.state.z_min = 0.2
w.state.z_max = 10.8
w.state.visible_axes = False
app.close()
def setup_method(self, method):
self.data = Data(label='d1',
x=[3.4, 2.3, -1.1, 0.3],
y=[3.2, 3.3, 3.4, 3.5],
z=['a', 'b', 'c', 'a'])
self.data_2d = Data(label='d2',
a=[[1, 2], [3, 4]],
b=[[5, 6], [7, 8]],
x=[[3, 5], [5.4, 1]],
y=[[1.2, 4], [7, 8]])
self.app = GlueApplication()
self.session = self.app.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.data_collection.append(self.data_2d)
self.viewer = self.app.new_data_viewer(ScatterViewer)
def test_indexed_data(capsys):
# Make sure that the image viewer works properly with IndexedData objects
data_4d = Data(label='hypercube_wcs',
x=np.random.random((3, 5, 4, 3)),
coords=WCS(naxis=4))
data_2d = IndexedData(data_4d, (2, None, 3, None))
application = GlueApplication()
session = application.session
hub = session.hub
data_collection = session.data_collection
data_collection.append(data_4d)
data_collection.append(data_2d)
viewer = application.new_data_viewer(ImageViewer)
viewer.add_data(data_2d)
assert viewer.state.x_att is data_2d.pixel_component_ids[1]
assert viewer.state.y_att is data_2d.pixel_component_ids[0]
assert viewer.state.x_att_world is data_2d.world_component_ids[1]
assert viewer.state.y_att_world is data_2d.world_component_ids[0]
process_events()
application.close()
# Some exceptions used to happen during callbacks, and these show up
# in stderr but don't interrupt the code, so we make sure here that
# nothing was printed to stdout nor stderr.
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
def test_table_with_dask_column():
da = pytest.importorskip('dask.array')
app = get_qapp()
d = Data(d=da.asarray([1, 2, 3, 4, 5]), e=np.arange(5) + 1)
dc = DataCollection([d])
gapp = GlueApplication(dc)
widget = gapp.new_data_viewer(TableViewer)
widget.add_data(d)
sg1 = dc.new_subset_group('D <= 3', d.id['d'] <= 3)
sg1.style.color = '#aa0000'
sg2 = dc.new_subset_group('1 < E < 4', (d.id['e'] > 1) & (d.id['e'] < 4))
sg2.style.color = '#0000cc'
assert widget.state.layers[0].visible
assert widget.state.layers[1].visible
assert widget.state.layers[2].visible
model = widget.ui.table.model()
# We now check what the data and colors of the table are, and try various
# sorting methods to make sure that things are still correct.
data = {'d': [1, 2, 3, 4, 5], 'e': [1, 2, 3, 4, 5]}
colors = ['#aa0000', '#380088', '#380088', None, None]
check_values_and_color(model, data, colors)
widget.state.layers[2].visible = False
colors = ['#aa0000', '#aa0000', '#aa0000', None, None]
check_values_and_color(model, data, colors)
def test_reset(tmpdir, capsys):
app = GlueApplication()
viewer = app.new_data_viewer(VispyScatterViewer)
data = Data(x=[1, 2, 3], label='Data')
app.data_collection.append(data)
app.show()
viewer.add_data(data)
assert viewer.state.x_min == 1.
assert viewer.state.y_min == 1.
assert viewer.state.z_min == 1.
assert viewer.state.x_max == 3.
assert viewer.state.y_max == 3.
assert viewer.state.z_max == 3.
viewer.state.x_min = 2
viewer.state.y_min = 3
viewer.state.z_min = 5
viewer.state.x_max = 6
viewer.state.y_max = 7
viewer.state.z_max = 8
viewer.toolbar.actions['vispy:reset'].trigger()
assert viewer.state.x_min == 1.
assert viewer.state.y_min == 1.
assert viewer.state.z_min == 1.
assert viewer.state.x_max == 3.
assert viewer.state.y_max == 3.
assert viewer.state.z_max == 3.
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
app.close()
def test_two_custom_viewer_classes():
class MyWidget1(CustomViewer):
text_box1_Widget1 = '_Hello'
def setup(self, text_box1_Widget1):
pass
class MyWidget2(CustomViewer):
text_box1_Widget2 = '_Hello'
text_box2_Widget2 = '_world'
def setup(self, text_box1_Widget2, text_box2_Widget2):
pass
app = GlueApplication()
dc = app.data_collection
d = Data(x=[1, 2, 3], label='test')
dc.append(d)
app.new_data_viewer(MyWidget1._widget_cls)
app.new_data_viewer(MyWidget2._widget_cls)
def test_save(tmpdir, capsys):
app = GlueApplication()
viewer = app.new_data_viewer(VispyScatterViewer)
data = Data(x=[1, 2, 3], label='Data')
app.data_collection.append(data)
app.show()
viewer.add_data(data)
filename = tmpdir.join('test.png').strpath
with patch('qtpy.compat.getsavefilename') as fd:
fd.return_value = filename, 'png'
viewer.toolbar.tools['save'].subtools[0].activate()
assert os.path.exists(filename)
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
app.close()
def test_table_title():
app = get_qapp() # noqa
data1 = Data(a=[1, 2, 3, 4, 5], label='test1')
data2 = Data(a=[1, 2, 3, 4, 5], label='test2')
dc = DataCollection([data1, data2])
gapp = GlueApplication(dc)
viewer = gapp.new_data_viewer(TableViewer)
assert viewer.windowTitle() == 'Table'
viewer.add_data(data1)
assert viewer.windowTitle() == 'Table: test1'
viewer.add_data(data2)
assert viewer.windowTitle() == 'Table: test2'
def test_close_on_last_layer_remove(self):
# regression test for 391
# Note: processEvents is needed for things to work correctly with PySide2
qtapp = get_qapp()
d1 = Data(x=np.random.random((2, ) * self.ndim))
d2 = Data(y=np.random.random((2, ) * self.ndim))
dc = DataCollection([d1, d2])
app = GlueApplication(dc)
w = app.new_data_viewer(self.widget_cls, data=d1)
w.add_data(d2)
qtapp.processEvents()
assert len(app.viewers[0]) == 1
dc.remove(d1)
qtapp.processEvents()
assert len(app.viewers[0]) == 1
dc.remove(d2)
qtapp.processEvents()
assert len(app.viewers[0]) == 0
app.close()
def setup_method(self, method):
"""
Parameters
----------
method
"""
# Set up simple spectral WCS
wcs_1d = WCS(naxis=1)
wcs_1d.wcs.ctype = ['VELO-LSR']
wcs_1d.wcs.set()
# Set up a spectral cube WCS
wcs_3d = WCS(naxis=3)
wcs_3d.wcs.ctype = ['RA---TAN', 'DEC--TAN', 'VELO-LSR']
wcs_3d.wcs.set()
# Set up glue Coordinates object
coords_1d = WCSCoordinates(wcs=wcs_1d)
coords_3d = WCSCoordinates(wcs=wcs_3d)
self.data_1d = Data(label='spectrum', coords=coords_1d)
self.data_3d = Data(label='spectrum', coords=coords_3d)
# FIXME: there should be an easier way to do this in glue
x = np.array([3.4, 2.3, -1.1, 0.3])
y = np.array([3.2, 3.3, 3.4, 3.5])
self.data_1d.add_component(Component(x, units='Jy'), 'x')
self.data_1d.add_component(Component(y, units='Jy'), 'y')
self.data_3d.add_component(Component(np.broadcast_to(x, (6, 5, 4)), units='Jy'), 'x')
self.data_3d.add_component(Component(np.broadcast_to(x, (6, 5, 4))), 'y')
self.app = GlueApplication()
self.session = self.app.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data_1d)
self.data_collection.append(self.data_3d)
def test_viewer_size(self, tmpdir):
# regression test for #781
# viewers were not restored with the right size
d1 = Data(x=np.random.random((2,) * self.ndim))
d2 = Data(x=np.random.random((2,) * self.ndim))
dc = DataCollection([d1, d2])
app = GlueApplication(dc)
w = app.new_data_viewer(self.widget_cls, data=d1)
w.viewer_size = (300, 400)
filename = tmpdir.join('session.glu').strpath
app.save_session(filename, include_data=True)
app2 = GlueApplication.restore_session(filename)
for viewer in app2.viewers:
assert viewer[0].viewer_size == (300, 400)
app.close()
app2.close()
def test_record(tmpdir, capsys):
app = GlueApplication()
viewer = app.new_data_viewer(VispyScatterViewer)
filename = tmpdir.join('test.gif').strpath
with patch('qtpy.compat.getsavefilename') as fd:
fd.return_value = filename, 'gif'
viewer.toolbar.actions['vispy:record'].toggle()
assert viewer.toolbar.active_tool.tool_id == 'vispy:record'
viewer.toolbar.actions['vispy:record'].toggle()
assert viewer.toolbar.active_tool is None
assert os.path.exists(filename)
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
app.close()
def test_incompatible_subset():
# Regression test for a bug that caused the table to be refreshed in an
# infinite loop if incompatible subsets were present.
data1 = Data(a=[1, 2, 3, 4, 5], label='test1')
data2 = Data(a=[1, 2, 3, 4, 5], label='test2')
dc = DataCollection([data1, data2])
gapp = GlueApplication(dc)
viewer = gapp.new_data_viewer(TableViewer)
viewer.add_data(data1)
dc.new_subset_group('test subset', data2.id['a'] > 2)
gapp.show()
process_events(0.5)
with patch.object(viewer.layers[0], '_refresh') as refresh1:
with patch.object(viewer.layers[1], '_refresh') as refresh2:
process_events(0.5)
assert refresh1.call_count == 0
assert refresh2.call_count == 0
def test_table_widget(tmpdir):
# Start off by creating a glue application instance with a table viewer and
# some data pre-loaded.
app = get_qapp()
d = Data(a=[1, 2, 3, 4, 5],
b=[3.2, 1.2, 4.5, 3.3, 2.2],
c=['e', 'b', 'c', 'a', 'f'])
dc = DataCollection([d])
gapp = GlueApplication(dc)
widget = gapp.new_data_viewer(TableViewer)
widget.add_data(d)
subset_mode = gapp._session.edit_subset_mode
# Create two subsets
sg1 = dc.new_subset_group('D <= 3', d.id['a'] <= 3)
sg1.style.color = '#aa0000'
sg2 = dc.new_subset_group('1 < D < 4', (d.id['a'] > 1) & (d.id['a'] < 4))
sg2.style.color = '#0000cc'
model = widget.ui.table.model()
# We now check what the data and colors of the table are, and try various
# sorting methods to make sure that things are still correct.
data = {
'a': [1, 2, 3, 4, 5],
'b': [3.2, 1.2, 4.5, 3.3, 2.2],
'c': ['e', 'b', 'c', 'a', 'f']
}
colors = ['#aa0000', '#380088', '#380088', None, None]
check_values_and_color(model, data, colors)
model.sort(1, Qt.AscendingOrder)
data = {
'a': [2, 5, 1, 4, 3],
'b': [1.2, 2.2, 3.2, 3.3, 4.5],
'c': ['b', 'f', 'e', 'a', 'c']
}
colors = ['#380088', None, '#aa0000', None, '#380088']
check_values_and_color(model, data, colors)
model.sort(2, Qt.AscendingOrder)
data = {
'a': [4, 2, 3, 1, 5],
'b': [3.3, 1.2, 4.5, 3.2, 2.2],
'c': ['a', 'b', 'c', 'e', 'f']
}
colors = [None, '#380088', '#380088', '#aa0000', None]
check_values_and_color(model, data, colors)
model.sort(0, Qt.DescendingOrder)
data = {
'a': [5, 4, 3, 2, 1],
'b': [2.2, 3.3, 4.5, 1.2, 3.2],
'c': ['f', 'a', 'c', 'b', 'e']
}
colors = [None, None, '#380088', '#380088', '#aa0000']
check_values_and_color(model, data, colors)
model.sort(0, Qt.AscendingOrder)
# We now modify the subsets using the table.
selection = widget.ui.table.selectionModel()
widget.toolbar.actions['table:rowselect'].toggle()
def press_key(key):
event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, key, Qt.NoModifier)
app.postEvent(widget.ui.table, event)
app.processEvents()
app.processEvents()
# We now use key presses to navigate down to the third row
press_key(Qt.Key_Tab)
press_key(Qt.Key_Down)
press_key(Qt.Key_Down)
indices = selection.selectedRows()
# We make sure that the third row is selected
assert len(indices) == 1
assert indices[0].row() == 2
# At this point, the subsets haven't changed yet
np.testing.assert_equal(d.subsets[0].to_mask(), [1, 1, 1, 0, 0])
np.testing.assert_equal(d.subsets[1].to_mask(), [0, 1, 1, 0, 0])
# We specify that we are editing the second subset, and use a 'not' logical
# operation to remove the currently selected line from the second subset.
subset_mode.edit_subset = [d.subsets[1]]
subset_mode.mode = AndNotMode
press_key(Qt.Key_Enter)
np.testing.assert_equal(d.subsets[0].to_mask(), [1, 1, 1, 0, 0])
np.testing.assert_equal(d.subsets[1].to_mask(), [0, 1, 0, 0, 0])
# At this point, the selection should be cleared
indices = selection.selectedRows()
assert len(indices) == 0
# We move to the fourth row and now do an 'or' selection with the first
# subset.
press_key(Qt.Key_Down)
subset_mode.mode = OrMode
subset_mode.edit_subset = [d.subsets[0]]
press_key(Qt.Key_Enter)
np.testing.assert_equal(d.subsets[0].to_mask(), [1, 1, 1, 1, 0])
np.testing.assert_equal(d.subsets[1].to_mask(), [0, 1, 0, 0, 0])
# Finally we move to the fifth row and deselect all subsets so that
# pressing enter now creates a new subset.
press_key(Qt.Key_Down)
subset_mode.mode = ReplaceMode
subset_mode.edit_subset = None
press_key(Qt.Key_Enter)
np.testing.assert_equal(d.subsets[0].to_mask(), [1, 1, 1, 1, 0])
np.testing.assert_equal(d.subsets[1].to_mask(), [0, 1, 0, 0, 0])
np.testing.assert_equal(d.subsets[2].to_mask(), [0, 0, 0, 0, 1])
# Make the color for the new subset deterministic
dc.subset_groups[2].style.color = '#bababa'
# Now finally check saving and restoring session
session_file = tmpdir.join('table.glu').strpath
gapp.save_session(session_file)
gapp2 = GlueApplication.restore_session(session_file)
gapp2.show()
d = gapp2.data_collection[0]
widget2 = gapp2.viewers[0][0]
model2 = widget2.ui.table.model()
data = {
'a': [1, 2, 3, 4, 5],
'b': [3.2, 1.2, 4.5, 3.3, 2.2],
'c': ['e', 'b', 'c', 'a', 'f']
}
# Need to take into account new selections above
colors = ['#aa0000', '#380088', '#aa0000', "#aa0000", "#bababa"]
check_values_and_color(model2, data, colors)
def setup_method(self, method):
d = Data(x=[1, 2, 3], y=[2, 3, 4], z=['a', 'b', 'c'], label='data')
dc = DataCollection([d])
self.app = GlueApplication(dc)
self.data = d
@data_factory('yt dataset', is_yt_dataset)
def read_yt(filename):
ds = yt.load(filename)
return YTGlueData(ds)
if __name__ == "__main__":
ds = yt.load('Enzo_64/DD0043/data0043')
def logdensity(field, data):
return np.log10(data['gas', 'density'])
ds.add_field(('gas', 'logdensity'),
function=logdensity,
units='',
sampling_type='cell')
def logtemperature(field, data):
return np.log10(data['gas', 'temperature'])
ds.add_field(('gas', 'logtemperature'),
function=logtemperature,
units='',
sampling_type='cell')
d1 = YTGlueData(ds)
dc = DataCollection([d1])
ga = GlueApplication(dc)
viewer = ga.new_data_viewer(VispyVolumeViewer)
viewer.add_data(d1)
ga.start(maximized=False)
def start_glue(gluefile=None, config=None, datafiles=None, maximized=True,
startup_actions=None, auto_merge=False):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
auto_merge : bool, optional
Whether to automatically merge data passed in `datafiles` (default is `False`)
"""
import glue
# Some Qt modules are picky in terms of being imported before the
# application is set up, so we import them here. We do it here rather
# than in get_qapp since in the past, including this code in get_qapp
# caused severe issues (e.g. segmentation faults) in plugin packages
# during testing.
try:
from qtpy import QtWebEngineWidgets # noqa
except ImportError: # Not all PyQt installations have this module
pass
from glue.utils.qt.decorators import die_on_error
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
splash.show()
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash, require_qt_plugins=True)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if gluefile is not None:
with die_on_error("Error restoring Glue session"):
app = GlueApplication.restore_session(gluefile, show=False)
return app.start(maximized=maximized)
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
splash.set_progress(100)
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
if datafiles:
with die_on_error("Error reading data file"):
datasets = load_data_files(datafiles)
ga.add_datasets(datasets, auto_merge=auto_merge)
if startup_actions is not None:
for name in startup_actions:
ga.run_startup_action(name)
return ga.start(maximized=maximized)
def main(argv=sys.argv):
"""
The majority of the code in this function was taken from start_glue() in main.py after a discussion with
Tom Robataille. We wanted the ability to get command line arguments and use them in here and this seemed
to be the cleanest way to do it.
:param argv:
:return:
"""
# # Parse the arguments, ignore any unkonwn
parser = argparse.ArgumentParser()
parser.add_argument("--data-configs", help="Directory or file for data configuration YAML files", action='append', default=[])
parser.add_argument("--data-configs-show", help="Show the matching info", action="store_true", default=False)
parser.add_argument('data_files', nargs=argparse.REMAINDER)
args = parser.parse_known_args(argv[1:])
# Store the args for each ' --data-configs' found on the commandline
data_configs = args[0].data_configs
data_configs_show = args[0].data_configs_show
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
# Splash screen
splash = get_splash()
splash.image = QtGui.QPixmap(CUBEVIZ_LOGO_PATH)
splash.show()
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
# Load the
DataFactoryConfiguration(data_configs, data_configs_show, remove_defaults=True)
datafiles = args[0].data_files
# Check to make sure each file exists and raise an Exception
# that will show in the popup if it does not exist.
for fileparam in datafiles:
for filename in fileparam.split(','):
if not os.path.isfile(filename.strip()):
raise IOError('The file {} does not exist'.format(filename))
# Show the splash screen for 1 second
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
data_collection = glue.core.DataCollection()
hub = data_collection.hub
splash.set_progress(100)
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
ga.setWindowTitle('cubeviz ({})'.format(cubeviz_version))
qapp = QtWidgets.QApplication.instance()
qapp.setWindowIcon(QtGui.QIcon(CUBEVIZ_ICON_PATH))
ga.setWindowIcon(QtGui.QIcon(CUBEVIZ_ICON_PATH))
ga.run_startup_action('cubeviz')
# Load the data files.
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=False)
sys.exit(ga.start(maximized=True))
def start_glue(gluefile=None,
config=None,
datafiles=None,
maximized=True,
startup_actions=None,
auto_merge=False):
"""Run a glue session and exit
Parameters
----------
gluefile : str
An optional ``.glu`` file to restore.
config : str
An optional configuration file to use.
datafiles : str
An optional list of data files to load.
maximized : bool
Maximize screen on startup. Otherwise, use default size.
auto_merge : bool, optional
Whether to automatically merge data passed in `datafiles` (default is `False`)
"""
import glue
from glue.utils.qt import get_qapp
app = get_qapp()
splash = get_splash()
splash.show()
# Start off by loading plugins. We need to do this before restoring
# the session or loading the configuration since these may use existing
# plugins.
load_plugins(splash=splash)
from glue.app.qt import GlueApplication
datafiles = datafiles or []
hub = None
from qtpy.QtCore import QTimer
timer = QTimer()
timer.setInterval(1000)
timer.setSingleShot(True)
timer.timeout.connect(splash.close)
timer.start()
if gluefile is not None:
app = restore_session(gluefile)
return app.start()
if config is not None:
glue.env = glue.config.load_configuration(search_path=[config])
data_collection = glue.core.DataCollection()
hub = data_collection.hub
splash.set_progress(100)
session = glue.core.Session(data_collection=data_collection, hub=hub)
ga = GlueApplication(session=session)
if datafiles:
datasets = load_data_files(datafiles)
ga.add_datasets(data_collection, datasets, auto_merge=auto_merge)
if startup_actions is not None:
for name in startup_actions:
ga.run_startup_action(name)
return ga.start(maximized=maximized)
def test_foreground_background_settings():
d_1d = Data(x=np.random.random(100),
y=np.random.random(100),
label='Data 1d')
d_2d = Data(x=np.random.random((100, 100)),
y=np.random.random((100, 100)),
label='Data 2d')
dc = DataCollection([d_1d, d_2d])
app = GlueApplication(dc)
# Make sure that settings change existing viewers, so we create a bunch of
# viewers here.
scatter1 = app.new_data_viewer(ScatterViewer)
scatter1.add_data(d_1d)
image1 = app.new_data_viewer(ImageViewer)
image1.add_data(d_2d)
histogram1 = app.new_data_viewer(HistogramViewer)
histogram1.add_data(d_1d)
dendrogram1 = app.new_data_viewer(DendroWidget)
example_custom = _generate_custom_viewer()
custom1 = app.new_data_viewer(example_custom)
RED = (1, 0, 0, 0.5)
GREEN = (0, 1, 0, 0.6)
app.show()
with patch('glue.config.settings') as settings:
settings.FOREGROUND_COLOR = 'black'
settings.BACKGROUND_COLOR = 'white'
settings.DATA_COLOR = '0.5'
settings.DATA_ALPHA = 0.5
dialog = PreferencesDialog(app)
dialog.show()
dialog.background = RED
dialog.foreground = GREEN
dialog.accept()
assert_axes_background(scatter1.axes, RED)
assert_axes_background(image1.axes, RED)
assert_axes_background(histogram1.axes, RED)
assert_axes_background(dendrogram1.axes, RED)
assert_axes_background(custom1.axes, RED)
assert_axes_foreground(scatter1.axes, GREEN)
assert_axes_foreground(image1.axes, GREEN)
assert_axes_foreground(histogram1.axes, GREEN)
assert_axes_foreground(dendrogram1.axes, GREEN)
assert_axes_foreground(custom1.axes, GREEN)
# Now make sure that new viewers also inherit these settings
scatter2 = app.new_data_viewer(ScatterViewer)
scatter2.add_data(d_1d)
image2 = app.new_data_viewer(ImageViewer)
image2.add_data(d_2d)
histogram2 = app.new_data_viewer(HistogramViewer)
histogram2.add_data(d_1d)
dendrogram2 = app.new_data_viewer(DendroWidget)
custom2 = app.new_data_viewer(example_custom)
assert_axes_background(scatter2.axes, RED)
assert_axes_background(image2.axes, RED)
assert_axes_background(histogram2.axes, RED)
assert_axes_background(dendrogram2.axes, RED)
assert_axes_background(custom2.axes, RED)
assert_axes_foreground(scatter2.axes, GREEN)
assert_axes_foreground(image2.axes, GREEN)
assert_axes_foreground(histogram2.axes, GREEN)
assert_axes_foreground(dendrogram2.axes, GREEN)
assert_axes_foreground(custom2.axes, GREEN)
def setup_method(self, method):
self.cube = Data(label='cube', x=np.arange(1000).reshape((5, 10, 20)))
self.application = GlueApplication()
self.application.data_collection.append(self.cube)
self.viewer = self.application.new_data_viewer(ImageViewer)
self.viewer.add_data(self.cube)
def test_state_save():
app = GlueApplication()
w = app.new_data_viewer(viewer._widget_cls)
check_clone_app(app)
