def glue_focus(xyz, labels):
"""
Launch a glue session with focusing results.
Parameters
----------
xyz : `~numpy.ndarray`
Matrix of (x, y, z) positions of particles
labels : `~numpy.ndarray`
Labels for particles assigned by clustering algorithm
Returns
-------
ga : `~glue.app.qt.application.GlueApplication`
Glue qt GUI application session
"""
from glue.core import DataCollection, Data
from glue.app.qt.application import GlueApplication
from glue_vispy_viewers.scatter.scatter_viewer import VispyScatterViewer
data = Data(x=xyz[:, 0], y=xyz[:, 1], z=xyz[:, 2],
clusters=labels, label='data')
dc = DataCollection([data])
# create a GUI session
ga = GlueApplication(dc)
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
return ga
def test_n_dimensional_data():
# Create fake data
data = Data(x=np.random.random((2, 3, 4, 5)),
y=np.random.random((2, 3, 4, 5)),
z=np.random.random((2, 3, 4, 5)))
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
layer_artist = scatter.layers[0]
style_widget = scatter._view.layout_style_widgets[layer_artist]
style_widget.size_mode = 'Linear'
style_widget.size_attribute = data.id['x']
style_widget.color_mode = 'Linear'
style_widget.cmap_attribute = data.id['y']
style_widget.cmap = cm.BuGn
def commit(self):
# Test if Glueviz is running or closed already
if self.gluvizapp is not None:
import sip
app = self.gluvizapp
if sip.isdeleted(app):
# Clear last instance closed
self.gluvizapp = None
self.infob.setText(
"Please click the button below to run Glueviz.")
return
# Glueviz is running
else:
return
from glue.core import DataCollection
from glue.qglue import parse_data
dc = DataCollection()
for table in self.tables.values():
gd = parse_data(table, table.name)
dc.append(gd[0])
# start Glue
from glue.app.qt.application import GlueApplication
self.gluvizapp = GlueApplication(dc)
# ------------------------------------------------------------------
# Very important!!! Can't open another QMainWindow without this line
self.windowList.append(self.gluvizapp)
self.close()
self.gluvizapp.start()
self.infob.setText("Glueviz is running.")
def test_session_round_trip(self, tmpdir):
self.init_subset()
ga = GlueApplication(self.data_collection)
ga.show()
viewer = ga.new_data_viewer(self.viewer_cls)
viewer.add_data(self.data)
session_file = tmpdir.join('test_session_round_trip.glu').strpath
ga.save_session(session_file)
ga.close()
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
viewer2 = ga2.viewers[0][0]
data2 = ga2.data_collection[0]
assert viewer2.layers[0].layer is data2
assert viewer2.layers[1].layer is data2.subsets[0]
ga2.close()
def to_glue(self, label="yt", data_collection=None):
"""
Takes the data in the FITSImageData instance and exports it to
Glue (http://glueviz.org) for interactive analysis. Optionally
add a *label*. If you are already within the Glue environment, you
can pass a *data_collection* object, otherwise Glue will be started.
"""
from glue.core import Data, DataCollection
from glue.core.coordinates import coordinates_from_header
try:
from glue.app.qt.application import GlueApplication
except ImportError:
from glue.qt.glue_application import GlueApplication
image = Data(label=label)
image.coords = coordinates_from_header(self.wcs.to_header())
for k in self.fields:
image.add_component(self[k].data, k)
if data_collection is None:
dc = DataCollection([image])
app = GlueApplication(dc)
app.start()
else:
data_collection.append(image)
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
arrays = a.create_array(('LANDSAT_5', 'nbar'), ['nir'], dimensions, 'get_data')
median_t = a.apply_generic_reduction(arrays, ['time'], 'median(array1)', 'medianT')
result = e.execute_plan(a.plan)
plot(e.cache['medianT'])
b40_result = e.cache['get_data']['array_result']['nir']
median_result = e.cache['medianT']['array_result']['medianT']
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
median_data = Data(x=median_result[::-1, :], label='medianT')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([median_data, b40_data, long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def glue_focus(xyz, labels):
"""
Launch a glue session with focusing results.
Parameters
----------
xyz : `~numpy.ndarray`
Matrix of (x, y, z) positions of particles
labels : `~numpy.ndarray`
Labels for particles assigned by clustering algorithm
Returns
-------
ga : `~glue.app.qt.application.GlueApplication`
Glue qt GUI application session
"""
from glue.core import DataCollection, Data
from glue.app.qt.application import GlueApplication
from glue_vispy_viewers.scatter.scatter_viewer import VispyScatterViewer
data = Data(x=xyz[:, 0],
y=xyz[:, 1],
z=xyz[:, 2],
clusters=labels,
label='data')
dc = DataCollection([data])
# create a GUI session
ga = GlueApplication(dc)
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
return ga
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
arrays = a.create_array(('LANDSAT_5', 'nbar'), ['nir', 'red'], dimensions, 'get_data')
ndvi = a.apply_bandmath(arrays, '((array1 - array2) / (array1 + array2))', 'ndvi')
e.execute_plan(a.plan)
plot(e.cache['ndvi'])
b30_result = e.cache['get_data']['array_result']['red']
b40_result = e.cache['get_data']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([ndvi_data, b30_data, b40_data, long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
ndvi = a.apply_sensor_specific_bandmath('LANDSAT_5', 'nbar', 'ndvi', dimensions, 'get_data', 'ndvi')
result = e.execute_plan(a.plan)
plot(e.cache['ndvi'])
b30_result = e.cache['get_data']['array_result']['red']
b40_result = e.cache['get_data']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([ndvi_data, b30_data, b40_data, long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def test_n_dimensional_data():
# Create fake data
data = Data(x=np.random.random((2,3,4,5)),
y=np.random.random((2,3,4,5)),
z=np.random.random((2,3,4,5)))
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
layer_artist = scatter.layers[0]
style_widget = scatter._view.layout_style_widgets[layer_artist]
style_widget.size_mode = 'Linear'
style_widget.size_attribute = data.id['x']
style_widget.color_mode = 'Linear'
style_widget.cmap_attribute = data.id['y']
style_widget.cmap = cm.BuGn
def test_error_bars(tmpdir):
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
scatter.viewer_size = (400, 500)
viewer_state = scatter.state
viewer_state.x_att = data.id['a']
viewer_state.y_att = data.id['f']
viewer_state.z_att = data.id['z']
layer_state = viewer_state.layers[0]
layer_state.xerr_visible = True
layer_state.xerr_attribute = data.id['b']
layer_state.yerr_visible = False
layer_state.yerr_attribute = data.id['c']
layer_state.zerr_visible = True
layer_state.zerr_attribute = data.id['d']
assert viewer_state.line_width == 1
# Check that writing a session works as expected.
session_file = tmpdir.join('test_error_bars.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
scatter_r = ga2.viewers[0][0]
layer_state = scatter_r.state.layers[0]
assert layer_state.xerr_visible
assert layer_state.xerr_attribute.label == 'b'
assert not layer_state.yerr_visible
assert layer_state.yerr_attribute.label == 'c'
assert layer_state.zerr_visible
assert layer_state.zerr_attribute.label == 'd'
assert scatter_r.state.line_width == 1
ga2.close()
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
b40 = a.create_array(('LANDSAT_5', 'nbar'), ['nir'], dimensions, 'b40')
b30 = a.create_array(('LANDSAT_5', 'nbar'), ['red'], dimensions, 'b30')
ndvi = a.apply_expression([b40, b30], '((array1 - array2) / (array1 + array2))', 'ndvi')
e.execute_plan(a.plan)
plot(e.cache['ndvi'])
b30_result = e.cache['b30']['array_result']['red']
b40_result = e.cache['b40']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([ndvi_data, b30_data, b40_data, long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
class TestExportPython(BaseTestExportPython):
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(cube=np.random.random((30, 50, 20)))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ImageViewer)
self.viewer.add_data(self.data)
# FIXME: On some platforms, using an integer label size
# causes some of the labels to be non-deterministically
# shifted by one pixel, so we pick a non-round font size
# to avoid this.
self.viewer.state.x_ticklabel_size = 8.21334111
self.viewer.state.y_ticklabel_size = 8.21334111
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_att(self, tmpdir):
self.viewer.state.x_att = self.data.pixel_component_ids[1]
self.viewer.state.y_att = self.data.pixel_component_ids[0]
self.assert_same(tmpdir)
def test_simple_visual(self, tmpdir):
self.viewer.state.layers[0].cmap = plt.cm.RdBu
self.viewer.state.layers[0].v_min = 0.2
self.viewer.state.layers[0].v_max = 0.8
self.viewer.state.layers[0].stretch = 'sqrt'
self.viewer.state.layers[0].stretch = 'sqrt'
self.viewer.state.layers[0].contrast = 0.9
self.viewer.state.layers[0].bias = 0.6
self.assert_same(tmpdir)
def test_slice(self, tmpdir):
self.viewer.state.x_att = self.data.pixel_component_ids[1]
self.viewer.state.y_att = self.data.pixel_component_ids[0]
self.viewer.state.slices = (2, 3, 4)
self.assert_same(tmpdir)
def test_aspect(self, tmpdir):
self.viewer.state.aspect = 'auto'
self.assert_same(tmpdir)
def test_subset(self, tmpdir):
self.data_collection.new_subset_group('mysubset',
self.data.id['cube'] > 0.5)
self.assert_same(tmpdir)
def test_subset_slice(self, tmpdir):
self.data_collection.new_subset_group('mysubset',
self.data.id['cube'] > 0.5)
self.test_slice(tmpdir)
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(cube=np.random.random((30, 50, 20)))
self.data_collection = DataCollection([self.data])
ga = GlueApplication(self.data_collection)
self.viewer = ga.new_data_viewer(ImageViewer)
self.viewer.add_data(self.data)
class TestExportPython(BaseTestExportPython):
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict(
(name, random_with_nan(100, nan_index=idx + 1))
for idx, name in enumerate('abcdefgh')))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(HistogramViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_visual(self, tmpdir):
self.viewer.state.layers[0].color = 'blue'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_simple_visual_legend(self, tmpdir):
self.viewer.state.legend.visible = True
self.viewer.state.layers[0].color = 'blue'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_cumulative(self, tmpdir):
self.viewer.state.cumulative = True
self.assert_same(tmpdir)
def test_normalize(self, tmpdir):
self.viewer.state.normalize = True
self.assert_same(tmpdir)
def test_subset(self, tmpdir):
self.data_collection.new_subset_group('mysubset',
self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_subset_legend(self, tmpdir):
self.viewer.state.legend.visible = True
self.data_collection.new_subset_group('mysubset',
self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_empty(self, tmpdir):
self.viewer.state.x_min = 10
self.viewer.state.x_max = 11
self.viewer.state.hist_x_min = 10
self.viewer.state.hist_x_max = 11
self.assert_same(tmpdir)
class TestExportPython(BaseTestExportPython):
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(cube=np.random.random((30, 50, 20)))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ImageViewer)
self.viewer.add_data(self.data)
# FIXME: On some platforms, using an integer label size
# causes some of the labels to be non-deterministically
# shifted by one pixel, so we pick a non-round font size
# to avoid this.
self.viewer.state.x_ticklabel_size = 8.21334111
self.viewer.state.y_ticklabel_size = 8.21334111
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_att(self, tmpdir):
self.viewer.state.x_att = self.data.pixel_component_ids[1]
self.viewer.state.y_att = self.data.pixel_component_ids[0]
self.assert_same(tmpdir)
def test_simple_visual(self, tmpdir):
self.viewer.state.layers[0].cmap = plt.cm.RdBu
self.viewer.state.layers[0].v_min = 0.2
self.viewer.state.layers[0].v_max = 0.8
self.viewer.state.layers[0].stretch = 'sqrt'
self.viewer.state.layers[0].stretch = 'sqrt'
self.viewer.state.layers[0].contrast = 0.9
self.viewer.state.layers[0].bias = 0.6
self.assert_same(tmpdir)
def test_slice(self, tmpdir):
self.viewer.state.x_att = self.data.pixel_component_ids[1]
self.viewer.state.y_att = self.data.pixel_component_ids[0]
self.viewer.state.slices = (2, 3, 4)
self.assert_same(tmpdir)
def test_aspect(self, tmpdir):
self.viewer.state.aspect = 'auto'
self.assert_same(tmpdir)
def test_subset(self, tmpdir):
self.data_collection.new_subset_group('mysubset', self.data.id['cube'] > 0.5)
self.assert_same(tmpdir)
def test_subset_slice(self, tmpdir):
self.data_collection.new_subset_group('mysubset', self.data.id['cube'] > 0.5)
self.test_slice(tmpdir)
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict((name, random_with_nan(100, nan_index=idx + 1)) for idx, name in enumerate('abcdefgh')))
self.data_collection = DataCollection([self.data])
ga = GlueApplication(self.data_collection)
self.viewer = ga.new_data_viewer(HistogramViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
def test_session_round_trip(self, tmpdir):
self.init_subset()
ga = GlueApplication(self.data_collection)
ga.show()
viewer = ga.new_data_viewer(self.viewer_cls)
viewer.add_data(self.data)
session_file = tmpdir.join('test_session_round_trip.glu').strpath
ga.save_session(session_file)
ga.close()
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
viewer2 = ga2.viewers[0][0]
data2 = ga2.data_collection[0]
assert viewer2.layers[0].layer is data2
assert viewer2.layers[1].layer is data2.subsets[0]
ga2.close()
def setup_method(self, method):
self.data = Data(label='d1')
self.data.coords = SimpleCoordinates()
with NumpyRNGContext(12345):
self.data['x'] = random_with_nan(48, 5).reshape((6, 4, 2))
self.data['y'] = random_with_nan(48, 12).reshape((6, 4, 2))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ProfileViewer)
self.viewer.add_data(self.data)
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict(
(name, random_with_nan(100, nan_index=idx + 1))
for idx, name in enumerate('abcdefgh')))
self.data['angle'] = np.random.uniform(0, 360, 100)
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ScatterViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
self.viewer.state.y_att = self.data.id['b']
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(cube=np.random.random((30, 50, 20)))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ImageViewer)
self.viewer.add_data(self.data)
# FIXME: On some platforms, using an integer label size
# causes some of the labels to be non-deterministically
# shifted by one pixel, so we pick a non-round font size
# to avoid this.
self.viewer.state.x_ticklabel_size = 8.21334111
self.viewer.state.y_ticklabel_size = 8.21334111
def glue_gui():
d = data_factories.load_data(DEIMOSTABLE)
dc = DataCollection([])
dc.append(d)
# Creates glue instance
app = GlueApplication(dc)
app.setVisible(True)
# Adds data to the MosVizViewer
app.new_data_viewer(MOSVizViewer)
app.viewers[0][0].add_data_for_testing(app.data_collection[0])
return app
def setup_method(self, method):
self.data = self.init_data()
self.application = GlueApplication()
self.session = self.application.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.viewer_cls(self.session)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
def gs9(data, vmin, vmax, percentile, stretch, cmap):
load_plugins()
if cmap is not None:
for cmap_name, cmap_obj in colormaps.members:
if cmap == cmap_name:
cmap = cmap_obj
break
else:
colormaps.add(cmap, cm.get_cmap(cmap))
cmap = cm.get_cmap(cmap)
ga = GlueApplication()
image = ga.new_data_viewer(ImageViewer)
datasets = []
for filename in data:
datasets.append(load_data(filename))
# Add datasets all in one go to do all linking in one pass
ga.add_datasets(datasets)
for d in ga.data_collection:
image.add_data(d)
for layer_state in image.state.layers:
if vmin is not None:
layer_state.v_min = vmin
if vmax is not None:
layer_state.v_min = vmax
if percentile is not None:
choices = ImageLayerState.percentile.get_choices(layer_state)
for choice in choices:
if percentile == choice:
percentile = choice
break
layer_state.percentile = percentile
if stretch is not None:
layer_state.stretch = stretch
if cmap is not None:
layer_state.cmap = cmap
image.viewer_size = (600, 600)
ga.gather_current_tab()
ga.start(maximized=False, size=(1024, 768))
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {
'x': {
'range': (149.07, 149.18)
},
'y': {
'range': (-35.32, -35.28)
},
'time': {
'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))
}
}
arrays = a.create_array(('LANDSAT_5', 'nbar'), ['nir'], dimensions,
'get_data')
median_t = a.apply_generic_reduction(arrays, ['time'], 'median(array1)',
'medianT')
result = e.execute_plan(a.plan)
plot(e.cache['medianT'])
b40_result = e.cache['get_data']['array_result']['nir']
median_result = e.cache['medianT']['array_result']['medianT']
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
median_data = Data(x=median_result[::-1, :], label='medianT')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([
median_data,
b40_data,
long_data,
lat_data,
time_data,
])
app = GlueApplication(collection)
app.start()
def test_categorical_color_size(tmpdir):
# Create fake data
data = make_test_data()
# Add categorical component
data['categorical'] = ['a', 'b'] * 50
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
viewer_state = scatter.state
viewer_state.x_att = data.id['a']
viewer_state.y_att = data.id['b']
viewer_state.z_att = data.id['z']
layer_state = viewer_state.layers[0]
layer_state.size_mode = 'Linear'
layer_state.size_attribute = data.id['categorical']
layer_state.color_mode = 'Linear'
layer_state.cmap_attribute = data.id['categorical']
ga.close()
def test_layer_visibility_clip():
# Regression test for a bug that meant that updating the clip data setting
# caused a layer to become visible even if it shouldn't be
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
volume = ga.new_data_viewer(VispyVolumeViewer)
volume.add_data(data)
assert volume.layers[0].visible
assert volume.layers[0]._multivol.enabled[0]
volume.layers[0].visible = False
assert not volume.layers[0].visible
assert not volume.layers[0]._multivol.enabled[0]
volume.state.clip_data = True
assert not volume.layers[0].visible
assert not volume.layers[0]._multivol.enabled[0]
ga.close()
def setup_method(self, method):
if OBJGRAPH_INSTALLED:
self.viewer_count_start = self.viewer_count
self.data = self.init_data()
self.application = GlueApplication()
self.session = self.application.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.viewer_cls(self.session)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict((name, random_with_nan(100, nan_index=idx + 1)) for idx, name in enumerate('abcdefgh')))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(HistogramViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
def test_array_shape(tmpdir):
# Create irregularly shaped data cube
data = make_test_data((3841, 48, 46))
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
volume = ga.new_data_viewer(VispyVolumeViewer)
volume.add_data(data)
viewer_state = volume.state
# Get layer artist style editor
layer_state = viewer_state.layers[0]
layer_state.attribute = data.id['b']
class TestExportPython(BaseTestExportPython):
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict((name, random_with_nan(100, nan_index=idx + 1)) for idx, name in enumerate('abcdefgh')))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(HistogramViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_visual(self, tmpdir):
self.viewer.state.layers[0].color = 'blue'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_cumulative(self, tmpdir):
self.viewer.state.cumulative = True
self.assert_same(tmpdir)
def test_normalize(self, tmpdir):
self.viewer.state.normalize = True
self.assert_same(tmpdir)
def test_subset(self, tmpdir):
self.data_collection.new_subset_group('mysubset', self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_empty(self, tmpdir):
self.viewer.state.x_min = 10
self.viewer.state.x_max = 11
self.viewer.state.hist_x_min = 10
self.viewer.state.hist_x_max = 11
self.assert_same(tmpdir)
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
b40 = a.create_array(('LANDSAT_5', 'nbar'), ['nir'], dimensions, 'b40')
b30 = a.create_array(('LANDSAT_5', 'nbar'), ['red'], dimensions, 'b30')
pq = a.create_array(('LANDSAT_5', 'pqa'), ['pixelquality'], dimensions, 'pq')
ndvi = a.apply_expression([b40, b30], '((array1 - array2) / (array1 + array2))', 'ndvi')
mask = a.apply_expression([ndvi, pq], 'array1{(array2 == 32767) | (array2 == 16383) | (array2 == 2457)}', 'mask')
median_t = a.apply_expression(mask, 'median(array1, 0)', 'medianT')
result = e.execute_plan(a.plan)
plot(e.cache['medianT'])
b30_result = e.cache['b30']['array_result']['red']
b40_result = e.cache['b40']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
pq_result = e.cache['pq']['array_result']['pixelquality']
mask_result = e.cache['mask']['array_result']['mask']
median_result = e.cache['medianT']['array_result']['medianT']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
pq_data = Data(x=pq_result[:, ::-1, :], label='pq')
mask_data = Data(x=mask_result[:, ::-1, :], label='mask')
median_data = Data(x=median_result[::-1, :], label='median')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([median_data, mask_data, pq_data, ndvi_data, b30_data, b40_data,
long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
b40 = a.create_array(('LANDSAT_5', 'nbar'), ['nir'], dimensions, 'b40')
b30 = a.create_array(('LANDSAT_5', 'nbar'), ['red'], dimensions, 'b30')
pq = a.create_array(('LANDSAT_5', 'pqa'), ['pixelquality'], dimensions, 'pq')
ndvi = a.apply_expression([b40, b30], '((array1 - array2) / (array1 + array2))', 'ndvi')
mask = a.apply_expression([ndvi, pq], 'array1{(array2 == 32767) | (array2 == 16383) | (array2 == 2457)}', 'mask')
median_t = a.apply_expression(mask, 'median(array1, 0)', 'medianT')
result = e.execute_plan(a.plan)
plot(e.cache['medianT'])
b30_result = e.cache['b30']['array_result']['red']
b40_result = e.cache['b40']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
pq_result = e.cache['pq']['array_result']['pixelquality']
mask_result = e.cache['mask']['array_result']['mask']
median_result = e.cache['medianT']['array_result']['medianT']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
pq_data = Data(x=pq_result[:, ::-1, :], label='pq')
mask_data = Data(x=mask_result[:, ::-1, :], label='mask')
median_data = Data(x=median_result[::-1, :], label='median')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([median_data, mask_data, pq_data, ndvi_data, b30_data, b40_data,
long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def test_scatter_remove_layer_artists(tmpdir):
# Regression test for a bug that caused layer states to not be removed
# when the matching layer artist was removed. This then caused issues when
# loading session files.
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
dc.new_subset_group(subset_state=data.id['x'] > 0.5, label='subset 1')
scatter.add_subset(data.subsets[0])
assert len(scatter.layers) == 2
assert len(scatter.state.layers) == 2
dc.remove_subset_group(dc.subset_groups[0])
assert len(scatter.layers) == 1
assert len(scatter.state.layers) == 1
# Check that writing a session works as expected.
session_file = tmpdir.join('test_scatter_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
ga2.close()
def test_save_d3po(tmpdir):
from glue.app.qt.application import GlueApplication
from glue.viewers.scatter.qt import ScatterViewer
from glue.viewers.histogram.qt import HistogramViewer
output = tmpdir.join('output.html').strpath
d = Data(x=[1, 2, 3], y=[2, 3, 4], label='data')
dc = DataCollection([d])
app = GlueApplication(dc)
app.new_data_viewer(ScatterViewer, data=d)
app.new_data_viewer(HistogramViewer, data=d)
save_d3po(app, output, launch=False)
app.close()
def test_layer_visibility_after_session(tmpdir):
# Regression test for a bug that caused layers to be incorrectly visible
# after saving and loading a session file.
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
viewer_state = scatter.state
layer_state = viewer_state.layers[0]
layer_state.visible = False
session_file = tmpdir.join('test_layer_visibility.glu').strpath
ga.save_session(session_file)
ga.close()
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
scatter_r = ga2.viewers[0][0]
viewer_state = scatter_r.state
layer_state = viewer_state.layers[0]
assert not layer_state.visible
# Make sure the multiscat layer is also not visible (this was where the bug was)
layer_artist = scatter_r.layers[0]
assert not layer_artist._multiscat.layers[layer_artist.id]['visible']
ga2.close()
def main():
a = AnalyticsEngine()
e = ExecutionEngine()
# Lake Burley Griffin
dimensions = {'x': {'range': (149.07, 149.18)},
'y': {'range': (-35.32, -35.28)},
'time': {'range': (datetime(1990, 1, 1), datetime(1990, 12, 31))}}
arrays = a.create_array(('LANDSAT_5', 'nbar'), ['nir', 'red'], dimensions, 'get_data')
ndvi = a.apply_bandmath(arrays, '((array1 - array2) / (array1 + array2))', 'ndvi')
pq = a.create_array(('LANDSAT_5', 'pqa'), ['pixelquality'], dimensions, 'pq')
mask = a.apply_cloud_mask(ndvi, pq, 'mask')
e.execute_plan(a.plan)
plot(e.cache['mask'])
b30_result = e.cache['get_data']['array_result']['red']
b40_result = e.cache['get_data']['array_result']['nir']
ndvi_result = e.cache['ndvi']['array_result']['ndvi']
pq_result = e.cache['pq']['array_result']['pixelquality']
mask_result = e.cache['mask']['array_result']['mask']
b30_data = Data(x=b30_result[:, ::-1, :], label='B30')
b40_data = Data(x=b40_result[:, ::-1, :], label='B40')
ndvi_data = Data(x=ndvi_result[:, ::-1, :], label='ndvi')
pq_data = Data(x=pq_result[:, ::-1, :], label='pq')
mask_data = Data(x=mask_result[:, ::-1, :], label='mask')
long_data = Data(x=b40_result.coords['x'], label='long')
lat_data = Data(x=b40_result.coords['y'], label='lat')
time_data = Data(x=b40_result.coords['time'], label='time')
collection = DataCollection([mask_data, pq_data, ndvi_data, b30_data, b40_data, long_data, lat_data, time_data, ])
app = GlueApplication(collection)
app.start()
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(cube=np.random.random((30, 50, 20)))
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ImageViewer)
self.viewer.add_data(self.data)
# FIXME: On some platforms, using an integer label size
# causes some of the labels to be non-deterministically
# shifted by one pixel, so we pick a non-round font size
# to avoid this.
self.viewer.state.x_ticklabel_size = 8.21334111
self.viewer.state.y_ticklabel_size = 8.21334111
def setup_method(self, method):
self.data = self.init_data()
self.application = GlueApplication()
self.session = self.application.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.viewer_cls(self.session)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
def test_scatter_on_volume(tmpdir):
data1 = Data(a=np.arange(60).reshape((3, 4, 5)))
data2 = Data(x=[1, 2, 3], y=[2, 3, 4], z=[3, 4, 5])
data3 = Data(b=np.arange(60).reshape((3, 4, 5)))
dc = DataCollection([data1, data2, data3])
dc.add_link(LinkSame(data1.pixel_component_ids[2], data2.id['x']))
dc.add_link(LinkSame(data1.pixel_component_ids[1], data2.id['y']))
dc.add_link(LinkSame(data1.pixel_component_ids[0], data2.id['z']))
ga = GlueApplication(dc)
ga.show()
volume = ga.new_data_viewer(VispyVolumeViewer)
volume.add_data(data1)
volume.add_data(data2)
volume.add_data(data3)
# Check that writing a session works as expected.
session_file = tmpdir.join('test_scatter_on_volume.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
volume_r = ga2.viewers[0][0]
assert len(volume_r.layers) == 3
ga2.close()
def test_scatter_remove_layer_artists(tmpdir):
# Regression test for a bug that caused layer states to not be removed
# when the matching layer artist was removed. This then caused issues when
# loading session files.
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
dc.new_subset_group(subset_state=data.id['x'] > 0.5, label='subset 1')
scatter.add_subset(data.subsets[0])
assert len(scatter.layers) == 2
assert len(scatter.state.layers) == 2
dc.remove_subset_group(dc.subset_groups[0])
assert len(scatter.layers) == 1
assert len(scatter.state.layers) == 1
# Check that writing a session works as expected.
session_file = tmpdir.join('test_scatter_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
def test_save_d3po(tmpdir):
from glue.app.qt.application import GlueApplication
from glue.viewers.scatter.qt import ScatterViewer
from glue.viewers.histogram.qt import HistogramViewer
output = tmpdir.join('output.html').strpath
d = Data(x=[1, 2, 3], y=[2, 3, 4], label='data')
dc = DataCollection([d])
app = GlueApplication(dc)
app.new_data_viewer(ScatterViewer, data=d)
app.new_data_viewer(HistogramViewer, data=d)
save_d3po(app, output, launch=False)
app.close()
def setup_method(self, method):
if OBJGRAPH_INSTALLED:
self.viewer_count_start = self.viewer_count
self.data = self.init_data()
self.application = GlueApplication()
self.session = self.application.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.viewer_cls(self.session)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
def test_add_data_with_incompatible_subsets(tmpdir):
data1 = Data(label="Data 1", x=np.arange(24).reshape((4, 3, 2)))
data2 = Data(label="Data 2", y=np.arange(24).reshape((4, 3, 2)))
dc = DataCollection([data1, data2])
ga = GlueApplication(dc)
ga.show()
# Subset is defined in terms of data2, so it's an incompatible subset
# for data1
dc.new_subset_group(subset_state=data2.id['y'] > 0.5, label='subset 1')
volume = ga.new_data_viewer(VispyVolumeViewer)
volume.add_data(data1)
ga.close()
def glue_gui():
d = data_factories.load_data(DEIMOSTABLE)
dc = DataCollection([])
dc.append(d)
# Creates glue instance
app = GlueApplication(dc)
app.setVisible(True)
# Adds data to the MosVizViewer
app.new_data_viewer(MOSVizViewer)
app.viewers[0][0].add_data_for_testing(app.data_collection[0])
return app
def test_add_data_with_incompatible_subsets(tmpdir):
# Regression test for a bug that an error when adding a dataset with an
# incompatible subset to a 3D scatter viewer.
data1 = Data(label="Data 1", x=[1, 2, 3])
data2 = Data(label="Data 2", y=[4, 5, 6])
dc = DataCollection([data1, data2])
ga = GlueApplication(dc)
ga.show()
# Subset is defined in terms of data2, so it's an incompatible subset
# for data1
dc.new_subset_group(subset_state=data2.id['y'] > 0.5, label='subset 1')
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data1)
ga.close()
def test_remove_subset_group():
# Regression test for a bug that meant that removing a subset caused an
# error when multiple viewers were present.
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
volume1 = ga.new_data_viewer(VispyVolumeViewer)
volume1.add_data(data)
volume2 = ga.new_data_viewer(VispyVolumeViewer)
volume2.add_data(data)
dc.new_subset_group(subset_state=data.id['a'] > 0, label='Subset 1')
dc.remove_subset_group(dc.subset_groups[0])
ga.close()
class TestExportPython(BaseTestExportPython):
def setup_method(self, method):
with NumpyRNGContext(12345):
self.data = Data(**dict((name, random_with_nan(100, nan_index=idx + 1)) for idx, name in enumerate('abcdefgh')))
self.data['angle'] = np.random.uniform(0, 360, 100)
self.data_collection = DataCollection([self.data])
self.app = GlueApplication(self.data_collection)
self.viewer = self.app.new_data_viewer(ScatterViewer)
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['a']
self.viewer.state.y_att = self.data.id['b']
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_nofill(self, tmpdir):
self.viewer.state.layers[0].fill = False
self.viewer.state.layers[0].size_scaling = 10
self.assert_same(tmpdir)
def test_simple_visual(self, tmpdir):
self.viewer.state.layers[0].color = 'blue'
self.viewer.state.layers[0].markersize = 30
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_cmap_mode(self, tmpdir):
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_att = self.data.id['c']
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.viewer.state.layers[0].cmap_vmin = 0.2
self.viewer.state.layers[0].cmap_vmax = 0.7
self.viewer.state.layers[0].alpha = 0.8
self.assert_same(tmpdir)
def test_cmap_mode_nofill(self, tmpdir):
self.viewer.state.layers[0].fill = False
self.test_cmap_mode(tmpdir)
def test_size_mode(self, tmpdir):
self.viewer.state.layers[0].size_mode = 'Linear'
self.viewer.state.layers[0].size_att = self.data.id['d']
self.viewer.state.layers[0].size_vmin = 0.1
self.viewer.state.layers[0].size_vmax = 0.8
self.viewer.state.layers[0].size_scaling = 0.4
self.viewer.state.layers[0].alpha = 0.7
self.assert_same(tmpdir)
def test_size_mode_nofill(self, tmpdir):
self.viewer.state.layers[0].fill = False
self.test_size_mode(tmpdir)
def test_line(self, tmpdir):
self.viewer.state.layers[0].line_visible = True
self.viewer.state.layers[0].linewidth = 10
self.viewer.state.layers[0].linestype = 'dashed'
self.viewer.state.layers[0].color = 'orange'
self.viewer.state.layers[0].alpha = 0.7
self.viewer.state.layers[0].markersize = 100
self.assert_same(tmpdir, tol=5)
def test_line_cmap(self, tmpdir):
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_vmin = 0.2
self.viewer.state.layers[0].cmap_vmax = 0.7
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.test_line(tmpdir)
def test_errorbarx(self, tmpdir):
self.viewer.state.layers[0].xerr_visible = True
self.viewer.state.layers[0].xerr_att = self.data.id['e']
self.viewer.state.layers[0].color = 'purple'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_errorbary(self, tmpdir):
self.viewer.state.layers[0].yerr_visible = True
self.viewer.state.layers[0].yerr_att = self.data.id['f']
self.viewer.state.layers[0].color = 'purple'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_errorbarxy(self, tmpdir):
self.viewer.state.layers[0].xerr_visible = True
self.viewer.state.layers[0].xerr_att = self.data.id['e']
self.viewer.state.layers[0].yerr_visible = True
self.viewer.state.layers[0].yerr_att = self.data.id['f']
self.viewer.state.layers[0].color = 'purple'
self.viewer.state.layers[0].alpha = 0.5
self.assert_same(tmpdir)
def test_errorbarxy_cmap(self, tmpdir):
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_vmin = 0.2
self.viewer.state.layers[0].cmap_vmax = 0.7
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.test_errorbarxy(tmpdir)
def _vector_common(self, tmpdir):
self.viewer.state.layers[0].vector_visible = True
self.viewer.state.layers[0].vy_att = self.data.id['g']
self.viewer.state.layers[0].vector_arrowhead = True
self.viewer.state.layers[0].vector_origin = 'tail'
self.viewer.state.layers[0].vector_scaling = 1.5
self.viewer.state.layers[0].color = 'teal'
self.viewer.state.layers[0].alpha = 0.9
self.assert_same(tmpdir)
def test_vector_cartesian(self, tmpdir):
self.viewer.state.layers[0].vector_mode = 'Cartesian'
self.viewer.state.layers[0].vx_att = self.data.id['h']
self._vector_common(tmpdir)
def test_vector_polar(self, tmpdir):
self.viewer.state.layers[0].vector_mode = 'Polar'
self.viewer.state.layers[0].vx_att = self.data.id['angle']
self._vector_common(tmpdir)
def test_vector_cartesian_cmap(self, tmpdir):
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_vmin = 0.2
self.viewer.state.layers[0].cmap_vmax = 0.7
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.test_vector_cartesian(tmpdir)
def test_vector_cartesian_xflip(self, tmpdir):
# Regression test for a bug that caused vectors to not be flipped
self.viewer.state.layers[0].vector_mode = 'Cartesian'
self.viewer.state.layers[0].vx_att = self.data.id['h']
self.viewer.state.flip_x()
self._vector_common(tmpdir)
def test_subset(self, tmpdir):
self.data_collection.new_subset_group('mysubset', self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_density_map_with_subset(self, tmpdir):
self.viewer.state.dpi = 2
self.viewer.state.layers[0].density_map = True
self.data_collection.new_subset_group('mysubset', self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_density_map_cmap_with_subset(self, tmpdir):
self.viewer.state.dpi = 2
self.viewer.state.layers[0].density_map = True
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_vmin = 0.2
self.viewer.state.layers[0].cmap_vmax = 0.7
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.data_collection.new_subset_group('mysubset', self.data.id['a'] > 0.5)
self.assert_same(tmpdir)
def test_cmap_mode_change(self, tmpdir):
# Regression test for a bug that caused scatter markers to not change
# color when going from Linear to Fixed mode
self.viewer.state.layers[0].size_mode = 'Linear'
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_mode = 'Fixed'
self.assert_same(tmpdir)
return self.shape[cid.axis]
else:
return 1
elif statistic == 'mean' or statistic == 'median':
return 0.5
elif statistic == 'percentile':
return percentile / 100
elif statistic == 'sum':
return self.size / 2
else:
final_shape = tuple(self.shape[i] for i in range(self.ndim)
if i not in axis)
return np.random.random(final_shape)
def compute_histogram(self, cid,
range=None, bins=None, log=False,
subset_state=None, subset_group=None):
return np.random.random(bins) * 100
# We now create a data object using the above class,
# and launch a a glue session
from glue.core import DataCollection
from glue.app.qt.application import GlueApplication
d = RandomData()
dc = DataCollection([d])
ga = GlueApplication(dc)
ga.start()
class BaseTestMatplotlibDataViewer(object):
"""
Base class to test viewers based on MatplotlibDataViewer. This only runs
a subset of tests that relate to functionality implemented in
MatplotlibDataViewer and specific viewers are responsible for implementing
a more complete test suite.
Viewers based on this should inherit from this test class and define the
following attributes:
* ``data``: an instance of a data object that works by default in the viewer
* ``viewer_cls``: the viewer class
It is then safe to assume that ``data_collection``, ``viewer``, and ``hub``
are defined when writing tests.
"""
def setup_method(self, method):
if OBJGRAPH_INSTALLED:
self.viewer_count_start = self.viewer_count
self.data = self.init_data()
self.application = GlueApplication()
self.session = self.application.session
self.hub = self.session.hub
self.data_collection = self.session.data_collection
self.data_collection.append(self.data)
self.viewer = self.viewer_cls(self.session)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
def init_subset(self):
cid = self.data.visible_components[0]
self.data_collection.new_subset_group('subset 1', cid > 0)
@property
def viewer_count(self):
app = get_qapp()
app.processEvents()
obj = objgraph.by_type(self.viewer_cls.__name__)
return len(obj)
def teardown_method(self, method):
if self.viewer is not None:
self.viewer.close()
self.application.close()
# The following is a check to make sure that once the viewer and
# application have been closed, there are no leftover references to
# the data viewer. This was introduced because there were previously
# circular references that meant that viewer instances were not
# properly garbage collected, which in turn meant they still reacted
# in some cases to events.
if OBJGRAPH_INSTALLED:
self.viewer = None
self.application = None
if self.viewer_count > self.viewer_count_start:
raise ValueError("No net viewers should be created in tests")
def test_add_data(self):
# Add a dataset with no subsets and make sure the appropriate layer
# state and layer artists are created
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data
def test_add_data_with_subset(self):
# Make sure that if subsets are present in the data, they are added
# automatically
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 2
assert self.viewer.layers[0].layer is self.data
assert self.viewer.layers[1].layer is self.data.subsets[0]
assert len(self.viewer.state.layers) == 2
assert self.viewer.state.layers[0].layer is self.data
assert self.viewer.state.layers[1].layer is self.data.subsets[0]
def test_adding_subset_adds_data(self):
# TODO: in future consider whether we want to deprecate this behavior
self.init_subset()
self.viewer.add_subset(self.data.subsets[0])
assert len(self.viewer.layers) == 2
assert self.viewer.layers[0].layer is self.data
assert self.viewer.layers[1].layer is self.data.subsets[0]
assert len(self.viewer.state.layers) == 2
assert self.viewer.state.layers[0].layer is self.data
assert self.viewer.state.layers[1].layer is self.data.subsets[0]
def test_add_data_then_subset(self):
# Make sure that if a subset is created in a dataset that has already
# been added to a viewer, the subset gets added
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data
self.init_subset()
assert len(self.viewer.layers) == 2
assert self.viewer.layers[0].layer is self.data
assert self.viewer.layers[1].layer is self.data.subsets[0]
assert len(self.viewer.state.layers) == 2
assert self.viewer.state.layers[0].layer is self.data
assert self.viewer.state.layers[1].layer is self.data.subsets[0]
def init_draw_count(self):
self.mpl_counter = MatplotlibDrawCounter(self.viewer.axes.figure)
@property
def draw_count(self):
return self.mpl_counter.draw_count
def test_single_draw(self):
# Make sure that the number of draws is kept to a minimum
self.init_draw_count()
self.init_subset()
assert self.draw_count == 0
self.viewer.add_data(self.data)
assert self.draw_count == 1
def test_update_subset(self):
self.init_draw_count()
# Check that updating a subset causes the plot to be updated
self.init_subset()
assert self.draw_count == 0
self.viewer.add_data(self.data)
count_before = self.draw_count
# Change the subset
cid = self.data.visible_components[0]
self.data.subsets[0].subset_state = cid > 1
# Make sure the figure has been redrawn
assert self.draw_count - count_before > 0
def test_double_add_ignored(self):
self.viewer.add_data(self.data)
assert len(self.viewer.state.layers) == 1
self.viewer.add_data(self.data)
assert len(self.viewer.state.layers) == 1
def test_removing_data_removes_layer_state(self):
# Removing data from data collection should remove data from viewer
self.viewer.add_data(self.data)
assert len(self.viewer.state.layers) == 1
self.data_collection.remove(self.data)
assert len(self.viewer.state.layers) == 0
def test_removing_data_removes_subsets(self):
# Removing data from data collection should remove subsets from viewer
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.state.layers) == 2
self.data_collection.remove(self.data)
assert len(self.viewer.state.layers) == 0
def test_removing_subset_removes_layers(self):
# Removing a layer artist removes the corresponding layer state. We need
# to do this with a subset otherwise the viewer is closed
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 2
assert len(self.viewer.state.layers) == 2
self.data_collection.remove_subset_group(self.data_collection.subset_groups[0])
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data
def test_removing_layer_artist_removes_layer_state(self):
# Removing a layer artist removes the corresponding layer state. We need
# to do this with a subset otherwise the viewer is closed
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 2
assert len(self.viewer.state.layers) == 2
# self.layers is a copy so we need to remove from the original list
self.viewer._layer_artist_container.remove(self.viewer.layers[1])
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data
def test_removing_layer_state_removes_layer_artist(self):
# Removing a layer artist removes the corresponding layer state. We need
# to do this with a subset otherwise the viewer is closed
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 2
assert len(self.viewer.state.layers) == 2
# self.layers is a copy so we need to remove from the original list
self.viewer.state.layers.pop(1)
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data
def test_new_subset_after_remove_data(self):
# Once we remove a dataset, if we make a new subset, it will not be
# added to the viewer
self.init_subset()
self.viewer.add_data(self.data)
assert len(self.viewer.layers) == 2
assert len(self.viewer.state.layers) == 2
self.viewer.state.layers.pop(0)
self.init_subset() # makes a new subset
assert len(self.data.subsets) == 2
assert len(self.viewer.layers) == 1
assert self.viewer.layers[0].layer is self.data.subsets[0]
assert len(self.viewer.state.layers) == 1
assert self.viewer.state.layers[0].layer is self.data.subsets[0]
def test_remove_not_present_ignored(self):
data = Data(label='not in viewer')
self.viewer.remove_data(data)
def test_limits_sync(self):
viewer_state = self.viewer.state
axes = self.viewer.axes
if axes.get_adjustable() == 'datalim':
pytest.xfail()
# Make sure that the viewer state and matplotlib viewer limits and log
# settings are in sync. We start by modifying the state and making sure
# that the axes follow.
viewer_state.x_min = 3
viewer_state.x_max = 9
viewer_state.y_min = -2
viewer_state.y_max = 3
assert axes.get_xlim() == (3, 9)
assert axes.get_ylim() == (-2, 3)
assert axes.get_xscale() == 'linear'
assert axes.get_yscale() == 'linear'
viewer_state.x_log = True
assert axes.get_xlim() == (3, 9)
assert axes.get_ylim() == (-2, 3)
assert axes.get_xscale() == 'log'
assert axes.get_yscale() == 'linear'
viewer_state.y_log = True
# FIXME: the limits for y don't seem right, should be adjusted because of log?
assert axes.get_xlim() == (3, 9)
assert axes.get_ylim() == (-2, 3)
assert axes.get_xscale() == 'log'
assert axes.get_yscale() == 'log'
# Check that changing the axes changes the state
# NOTE: at the moment this doesn't work because Matplotlib doesn't
# emit events for changing xscale/yscale. This isn't crucial anyway for
# glue, but leaving the tests below in case this is fixed some day. The
# Matplotlib issue is https://github.com/matplotlib/matplotlib/issues/8439
axes.set_xscale('linear')
#
# assert viewer_state.x_min == 3
# assert viewer_state.x_max == 9
# assert viewer_state.y_min == -2
# assert viewer_state.y_max == 3
# assert not viewer_state.x_log
# assert viewer_state.y_log
#
axes.set_yscale('linear')
#
# assert viewer_state.x_min == 3
# assert viewer_state.x_max == 9
# assert viewer_state.y_min == -2
# assert viewer_state.y_max == 3
# assert not viewer_state.x_log
# assert not viewer_state.y_log
axes.set_xlim(-1, 4)
assert viewer_state.x_min == -1
assert viewer_state.x_max == 4
assert viewer_state.y_min == -2
assert viewer_state.y_max == 3
# assert not viewer_state.x_log
# assert not viewer_state.y_log
axes.set_ylim(5, 6)
assert viewer_state.x_min == -1
assert viewer_state.x_max == 4
assert viewer_state.y_min == 5
assert viewer_state.y_max == 6
# assert not viewer_state.x_log
# assert not viewer_state.y_log
# TODO: the following test should deal gracefully with the fact that
# some viewers will want to show a Qt error for IncompatibleDataException
def test_add_invalid_data(self):
data2 = Data()
with pytest.raises(IncompatibleDataException):
self.viewer.add_data(data2)
# Communication tests
def test_ignore_data_add_message(self):
self.data_collection.append(self.data)
assert len(self.viewer.layers) == 0
def test_update_data_ignored_if_data_not_present(self):
self.init_draw_count()
self.data_collection.append(self.data)
ct0 = self.draw_count
self.data.style.color = 'blue'
assert self.draw_count == ct0
def test_update_data_processed_if_data_present(self):
self.init_draw_count()
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
ct0 = self.draw_count
self.data.style.color = 'blue'
assert self.draw_count > ct0
def test_add_subset_ignored_if_data_not_present(self):
self.data_collection.append(self.data)
sub = self.data.new_subset()
assert sub not in self.viewer._layer_artist_container
def test_add_subset_processed_if_data_present(self):
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
sub = self.data.new_subset()
assert sub in self.viewer._layer_artist_container
def test_update_subset_ignored_if_not_present(self):
# This can be quite a difficult test to pass because it makes sure that
# there are absolutely no references to the layer state left over once
# a subset is removed - when originally written this identified quite
# a few places where references were being accidentally kept, and
# resulted in weakref being needed in a number of places. But ultimately
# this test should pass! No cheating :)
self.init_draw_count()
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
sub = self.data.new_subset()
self.viewer.remove_subset(sub)
ct0 = self.draw_count
sub.style.color = 'blue'
assert self.draw_count == ct0
def test_update_subset_processed_if_present(self):
self.init_draw_count()
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
sub = self.data.new_subset()
ct0 = self.draw_count
sub.style.color = 'blue'
assert self.draw_count > ct0
def test_data_remove_message(self):
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
self.data_collection.remove(self.data)
assert self.data not in self.viewer._layer_artist_container
def test_subset_remove_message(self):
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
sub = self.data.new_subset()
assert sub in self.viewer._layer_artist_container
sub.delete()
assert sub not in self.viewer._layer_artist_container
def test_session_round_trip(self, tmpdir):
self.init_subset()
ga = GlueApplication(self.data_collection)
ga.show()
viewer = ga.new_data_viewer(self.viewer_cls)
viewer.add_data(self.data)
session_file = tmpdir.join('test_session_round_trip.glu').strpath
ga.save_session(session_file)
ga.close()
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
viewer2 = ga2.viewers[0][0]
data2 = ga2.data_collection[0]
assert viewer2.layers[0].layer is data2
assert viewer2.layers[1].layer is data2.subsets[0]
ga2.close()
def test_apply_roi_undo(self):
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
roi = XRangeROI(1, 2)
self.viewer.apply_roi(roi)
assert len(self.data.subsets) == 1
lo1 = self.data.subsets[0].subset_state.lo
hi1 = self.data.subsets[0].subset_state.hi
roi = XRangeROI(0, 3)
self.viewer.apply_roi(roi)
assert len(self.data.subsets) == 1
lo2 = self.data.subsets[0].subset_state.lo
hi2 = self.data.subsets[0].subset_state.hi
assert lo2 != lo1
assert hi2 != hi1
self.application.undo()
assert len(self.data.subsets) == 1
assert self.data.subsets[0].subset_state.lo == lo1
assert self.data.subsets[0].subset_state.hi == hi1
self.application.redo()
assert len(self.data.subsets) == 1
assert self.data.subsets[0].subset_state.lo == lo2
assert self.data.subsets[0].subset_state.hi == hi2
def test_numerical_data_changed(self):
self.init_draw_count()
self.init_subset()
assert self.draw_count == 0
self.viewer.add_data(self.data)
assert self.draw_count == 1
data = Data()
for cid in self.data.visible_components:
data.add_component(self.data[cid] * 2, cid.label)
self.data.update_values_from_data(data)
assert self.draw_count == 2
from glue.core.data_factories import load_data
from glue.core import DataCollection
from glue.core.link_helpers import LinkSame
from glue.app.qt.application import GlueApplication
#load 2 datasets from files
image = load_data('w5.fits')
catalog = load_data('w5_psc.vot')
dc = DataCollection([image, catalog])
# link positional information
dc.add_link(LinkSame(image.id['World x: RA---TAN'], catalog.id['RAJ2000']))
dc.add_link(LinkSame(image.id['World y: DEC--TAN'], catalog.id['DEJ2000']))
#start Glue
app = GlueApplication(dc)
app.start()
def test_volume_viewer(tmpdir):
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
volume = ga.new_data_viewer(VispyVolumeViewer)
volume.add_data(data)
volume.viewer_size = (400, 500)
options = volume.options_widget()
options.x_stretch = 0.5
options.y_stretch = 1.0
options.z_stretch = 2.0
options.x_min = -0.1
options.x_max = 10.1
options.y_min = 0.1
options.y_max = 10.9
options.z_min = 0.2
options.z_max = 10.8
options.visible_box = False
# Get layer artist style editor
layer_artist = volume.layers[0]
style_widget = volume._view.layout_style_widgets[layer_artist]
style_widget.attribute = data.id['b']
style_widget.vmin = 0.1
style_widget.vmax = 0.9
style_widget.alpha = 0.8
# Check that writing a session works as expected.
session_file = tmpdir.join('test_volume_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
volume_r = ga2.viewers[0][0]
assert volume_r.viewer_size == (400, 500)
options = volume_r.options_widget()
assert options.x_stretch == 0.5
assert options.y_stretch == 1.0
assert options.z_stretch == 2.0
assert options.x_min == -0.1
assert options.x_max == 10.1
assert options.y_min == 0.1
assert options.y_max == 10.9
assert options.z_min == 0.2
assert options.z_max == 10.8
assert not options.visible_box
layer_artist = volume_r.layers[0]
assert style_widget.attribute.label == 'b'
assert style_widget.vmin == 0.1
assert style_widget.vmax == 0.9
assert style_widget.alpha == 0.8
ga2.close()
def test_scatter_viewer(tmpdir):
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
scatter.viewer_size = (400, 500)
options = scatter.options_widget()
options.x_att = data.id['a']
options.y_att = data.id['f']
options.z_att = data.id['z']
options.x_stretch = 0.5
options.y_stretch = 1.0
options.z_stretch = 2.0
options.x_min = -0.1
options.x_max = 1.1
options.y_min = 0.1
options.y_max = 0.9
options.z_min = 0.2
options.z_max = 0.8
options.visible_box = False
# Get layer artist style editor
layer_artist = scatter.layers[0]
style_widget = scatter._view.layout_style_widgets[layer_artist]
style_widget.size_mode = 'Linear'
style_widget.size_attribute = data.id['c']
style_widget.size_scaling = 2
style_widget.size_vmin = 0.2
style_widget.size_vmax = 0.8
style_widget.color_mode = 'Linear'
style_widget.cmap_attribute = data.id['y']
style_widget.cmap_vmin = 0.1
style_widget.cmap_vmax = 0.9
style_widget.cmap = cm.BuGn
# Check that writing a session works as expected. However, this only
# works with Glue 0.8 and above, so we skip this test if we are using an
# older version.
if GLUE_LT_08:
return
session_file = tmpdir.join('test_scatter_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
scatter_r = ga2.viewers[0][0]
assert scatter_r.viewer_size == (400, 500)
options = scatter_r.options_widget()
assert options.x_att.label == 'a'
assert options.y_att.label == 'f'
assert options.z_att.label == 'z'
assert options.x_stretch == 0.5
assert options.y_stretch == 1.0
assert options.z_stretch == 2.0
assert options.x_min == -0.1
assert options.x_max == 1.1
assert options.y_min == 0.1
assert options.y_max == 0.9
assert options.z_min == 0.2
assert options.z_max == 0.8
assert not options.visible_box
layer_artist = scatter_r.layers[0]
assert layer_artist.size_mode == 'linear'
assert layer_artist.size_attribute.label == 'c'
np.testing.assert_allclose(layer_artist.size_scaling, 2, rtol=0.01)
assert layer_artist.size_vmin == 0.2
assert layer_artist.size_vmax == 0.8
assert layer_artist.color_mode == 'linear'
assert layer_artist.cmap_attribute.label == 'y'
assert layer_artist.cmap_vmin == 0.1
assert layer_artist.cmap_vmax == 0.9
assert layer_artist.cmap is cm.BuGn
def test_volume_viewer(tmpdir):
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
volume = ga.new_data_viewer(VispyIsosurfaceViewer)
volume.add_data(data)
volume.viewer_size = (400, 500)
viewer_state = volume.state
viewer_state.x_stretch = 0.5
viewer_state.y_stretch = 1.0
viewer_state.z_stretch = 2.0
viewer_state.x_min = -0.1
viewer_state.x_max = 10.1
viewer_state.y_min = 0.1
viewer_state.y_max = 10.9
viewer_state.z_min = 0.2
viewer_state.z_max = 10.8
viewer_state.visible_axes = False
# Get layer artist style editor
layer_state = viewer_state.layers[0]
layer_state.attribute = data.id['b']
layer_state.level_low = 0.1
layer_state.level_high = 0.9
# layer_state.alpha = 0.8
# test set label from slider
layer_state.step = 5
assert layer_state.step == 5.0
# Check that writing a session works as expected.
session_file = tmpdir.join('test_volume_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
volume_r = ga2.viewers[0][0]
assert volume_r.viewer_size == (400, 500)
viewer_state = volume_r.state
np.testing.assert_allclose(viewer_state.x_stretch, 0.5, rtol=1e-3)
np.testing.assert_allclose(viewer_state.y_stretch, 1.0, rtol=1e-3)
np.testing.assert_allclose(viewer_state.z_stretch, 2.0, rtol=1e-3)
assert viewer_state.x_min == -0.1
assert viewer_state.x_max == 10.1
assert viewer_state.y_min == 0.1
assert viewer_state.y_max == 10.9
assert viewer_state.z_min == 0.2
assert viewer_state.z_max == 10.8
assert not viewer_state.visible_axes
layer_artist = viewer_state.layers[0]
assert layer_artist.attribute.label == 'b'
assert layer_artist.level_low == 0.1
assert layer_artist.level_high == 0.9
# assert layer_artist.alpha == 0.8
assert layer_artist.step == 5
ga2.close()
def test_scatter_viewer(tmpdir):
# Create fake data
data = make_test_data()
# Create fake session
dc = DataCollection([data])
ga = GlueApplication(dc)
ga.show()
scatter = ga.new_data_viewer(VispyScatterViewer)
scatter.add_data(data)
scatter.viewer_size = (400, 500)
viewer_state = scatter.state
viewer_state.x_att = data.id['a']
viewer_state.y_att = data.id['f']
viewer_state.z_att = data.id['z']
viewer_state.x_stretch = 0.5
viewer_state.y_stretch = 1.0
viewer_state.z_stretch = 2.0
viewer_state.x_min = -0.1
viewer_state.x_max = 1.1
viewer_state.y_min = 0.1
viewer_state.y_max = 0.9
viewer_state.z_min = 0.2
viewer_state.z_max = 0.8
viewer_state.visible_axes = False
# Get layer artist style editor
layer_state = viewer_state.layers[0]
layer_state.size_attribute = data.id['c']
layer_state.size_mode = 'Linear'
layer_state.size_scaling = 2
layer_state.size_vmin = 0.2
layer_state.size_vmax = 0.8
layer_state.cmap_attribute = data.id['y']
layer_state.color_mode = 'Linear'
layer_state.cmap_vmin = 0.1
layer_state.cmap_vmax = 0.9
layer_state.cmap = cm.BuGn
# Check that writing a session works as expected.
session_file = tmpdir.join('test_scatter_viewer.glu').strpath
ga.save_session(session_file)
ga.close()
# Now we can check that everything is restored correctly
ga2 = GlueApplication.restore_session(session_file)
ga2.show()
scatter_r = ga2.viewers[0][0]
assert scatter_r.viewer_size == (400, 500)
viewer_state = scatter_r.state
assert viewer_state.x_att.label == 'a'
assert viewer_state.y_att.label == 'f'
assert viewer_state.z_att.label == 'z'
np.testing.assert_allclose(viewer_state.x_stretch, 0.5, rtol=1e-3)
np.testing.assert_allclose(viewer_state.y_stretch, 1.0, rtol=1e-3)
np.testing.assert_allclose(viewer_state.z_stretch, 2.0, rtol=1e-3)
assert viewer_state.x_min == -0.1
assert viewer_state.x_max == 1.1
assert viewer_state.y_min == 0.1
assert viewer_state.y_max == 0.9
assert viewer_state.z_min == 0.2
assert viewer_state.z_max == 0.8
assert not viewer_state.visible_axes
layer_state = viewer_state.layers[0]
assert layer_state.size_mode == 'Linear'
assert layer_state.size_attribute.label == 'c'
np.testing.assert_allclose(layer_state.size_scaling, 2, rtol=0.01)
assert layer_state.size_vmin == 0.2
assert layer_state.size_vmax == 0.8
assert layer_state.color_mode == 'Linear'
assert layer_state.cmap_attribute.label == 'y'
assert layer_state.cmap_vmin == 0.1
assert layer_state.cmap_vmax == 0.9
assert layer_state.cmap is cm.BuGn
