@4 plOj pQ'y_Kp?W쳂(p ^W17WCԫzAs.l.r-u&DY Tc x 2րEpxMun i. xǝVJ>!(ƑGГ=Au6Py:ʽ>u* ͎ QgKCYg1tl@ An3(mFX /}aj"2M~6ťhYȋy.zᱧ~,<%R&+qy
: `A+>^4 \~l5&iҬAG -x5 ~Xe˖հqϸ V vοf:$VZkF+صk]uK., }GSNA>;iۍ4ۗ *MY
|#YˋyK7 gwdʑf;K.X@ 33%[K'k J ϱT3JWqRlL<9)tLSb[*̰ x~;z }wEGg ~~Ѐ=J ;RE+Ei mE 8%z㯜PAs+(\4Js cVtO;d0uCDqF՜<54AT~}.W>>z?[puYu&+@* k1p˒1dt `aFm>ۼ7'i˙LL;.S2 8O}|>_%Q-3#լHqfdک2xֺ~|'+ʞ|{NB$3
@ \ТH0
@qI1}
f_93g; 27:5qLFĶFby)RBo+3 o?+eDoPVq9M/QMY}zi8 rFDT "Q mdLn)3
@
A㊮'`y0F*ynٺPGPYY) ~/J8sF Ý%,+Ёng
; GX٭SAe O9 eͱJ&żEQECmڸ=p5C} Nj V@
C.rR:wm2ض\nqpY' 3 Y
C&s( /?z^re2eұpHXD,{z9`@zZe`4ȑl @9aQ 07Y7 0
ԁ010v(qr4 +C%2p>Gg Ȑg8%9` (pb3)3Eme֭|9Ɣ ήQ 9Vf%`x+5
ͻ5 ( WmP؉@zS4Lq2VnP1 Q 3mgKjO&8P i Z2AI[hٖE8 ])
F 7l@}%|k Fɜ|lxiG[ [>۶mkRCCҋQHbG3߮s {)['q >X34= LooseVersion(version)
installed = True
except (ImportError, AssertionError):
installed = False
return installed, pytest.mark.skipif(str(not installed), reason='Requires %s' % label)
ASTROPY_INSTALLED, requires_astropy = make_skipper('astropy',
label='Astropy')
MATPLOTLIB_GE_22, requires_matplotlib_ge_22 = make_skipper('matplotlib', version='2.2')
ASTRODENDRO_INSTALLED, requires_astrodendro = make_skipper('astrodendro')
SCIPY_INSTALLED, requires_scipy = make_skipper('scipy',
label='SciPy')
PIL_INSTALLED, requires_pil = make_skipper('PIL', label='PIL')
SKIMAGE_INSTALLED, requires_skimage = make_skipper('skimage',
label='scikit-image')
XLRD_INSTALLED, requires_xlrd = make_skipper('xlrd')
PYAVM_INSTALLED, requires_pyavm = make_skipper('pyavm')
PLOTLY_INSTALLED, requires_plotly = make_skipper('plotly')
IPYTHON_INSTALLED, requires_ipython = make_skipper('IPython')
requires_pil_or_skimage = pytest.mark.skipif(str(not SKIMAGE_INSTALLED and not PIL_INSTALLED),
reason='Requires PIL or scikit-image')
PLOTLY_INSTALLED, requires_plotly = make_skipper('plotly')
H5PY_INSTALLED, requires_h5py = make_skipper('h5py')
PYQT5_INSTALLED, requires_pyqt5 = make_skipper('PyQt5')
PYSIDE2_INSTALLED, requires_pyside2 = make_skipper('PySide2')
HYPOTHESIS_INSTALLED, requires_hypothesis = make_skipper('hypothesis')
QT_INSTALLED = PYQT5_INSTALLED or PYSIDE2_INSTALLED
SPECTRAL_CUBE_INSTALLED, requires_spectral_cube = make_skipper('spectral_cube',
label='spectral-cube')
requires_qt = pytest.mark.skipif(str(not QT_INSTALLED),
reason='An installation of Qt is required')
@contextmanager
def make_file(contents, suffix, decompress=False):
"""Context manager to write data to a temporary file,
and delete on exit
:param contents: Data to write. string
:param suffix: File suffix. string
"""
if decompress:
contents = zlib.decompress(contents)
try:
_, fname = tempfile.mkstemp(suffix=suffix)
with open(fname, 'wb') as outfile:
outfile.write(contents)
yield fname
finally:
try:
os.unlink(fname)
except WindowsError: # on Windows the unlink can fail
pass
glueviz-1.0.1+dfsg.orig/glue/tests/data/ 0000755 0001750 0001750 00000000000 14001427230 017404 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/tests/data/simple_table_resaved.glu 0000644 0001750 0001750 00000006415 13610101121 024265 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 2
},
"Component_0": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 3
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 4,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"components": [
"CoordinateComponent",
"CoordinateComponent_0",
"Component",
"Component_0"
],
"data": [
"single_table[HDU1]"
],
"groups": [],
"links": [],
"subset_group_count": 0
},
"LoadLog": {
"_protocol": 2,
"_type": "glue.core.data_factories.helpers.LoadLog",
"factory": {
"_type": "types.FunctionType",
"function": "glue.core.data_factories.fits.fits_reader"
},
"kwargs": [
[]
],
"path": "{DATA_PATH}/single_table.fits"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.viewers.scatter.qt",
"glue.plugins.data_factories.spectral_cube",
"glue.core.data_exporters",
"glue.viewers.image.qt",
"glue.plugins.coordinate_helpers",
"glue.plugins.tools",
"glue.viewers.table.qt",
"glue.plugins.dendro_viewer.qt",
"glue.viewers.histogram.qt",
"glue.plugins.wcs_autolinking",
"glue.io.formats.fits",
"glue.plugins.tools.pv_slicer",
"glue.plugins.export_d3po",
"glue.viewers.profile.qt"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"label": "b"
},
"single_table[HDU1]": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"a",
"Component"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "single_table[HDU1]",
"meta": {
"_type": "collections.OrderedDict",
"contents": {}
},
"primary_owner": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#595959",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "d804c55e-ebee-4850-a0f1-3b854bda62b4"
}
}
glueviz-1.0.1+dfsg.orig/glue/tests/data/glue_v0.7_pixel_roi_selection.glu 0000644 0001750 0001750 00000020026 13455362716 025765 0 ustar noahfx noahfx {
"CoordinateComponent_2": {
"world": true,
"_type": "glue.core.component.CoordinateComponent",
"axis": 1
},
"CoordinateComponent_1": {
"world": true,
"_type": "glue.core.component.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_0": {
"world": false,
"_type": "glue.core.component.CoordinateComponent",
"axis": 1
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"session": "Session",
"data": "DataCollection",
"viewers": [
[
"ImageWidget"
]
],
"plugins": [
"glue.plugins.tools.pv_slicer",
"glue.viewers.histogram",
"glue.plugins.export_plotly",
"glue.plugins.export_d3po",
"glue.viewers.image",
"glue.plugins.tools.spectrum_tool",
"glue.viewers.scatter",
"glue.plugins.coordinate_helpers"
]
},
"1_0": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#e31a1c",
"markersize": 7,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"group": "1",
"_type": "glue.core.subset_group.GroupedSubset"
},
"World 1": {
"hidden": true,
"_type": "glue.core.component_id.ComponentID",
"label": "World 1"
},
"image_0": {
"hidden": false,
"_type": "glue.core.component_id.ComponentID",
"label": "image"
},
"CoordinateComponent": {
"world": false,
"_type": "glue.core.component.CoordinateComponent",
"axis": 0
},
"Component": {
"units": "None",
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsIDIpLCB9ICAgICAgICAgIAoAAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8AAAAAAADwPwAAAAAAAPA/AAAAAAAA8D8="
}
},
"1": {
"_type": "glue.core.subset_group.SubsetGroup",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#e31a1c",
"markersize": 7,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"state": "RoiSubsetState",
"subsets": [
"1_0"
],
"label": "1"
},
"ImageWidget": {
"layers": [
{
"visible": true,
"layer": "image",
"zorder": 1,
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"norm": "DS9Normalize"
},
{
"visible": true,
"layer": "1_0",
"zorder": 2,
"_type": "glue.viewers.image.layer_artist.SubsetImageLayerArtist"
}
],
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"pos": [
0,
0
],
"session": "Session",
"properties": {
"rgb_viz": [
true,
true,
true
],
"ratt": null,
"rgb_mode": false,
"gatt": null,
"attribute": "image_0",
"batt": null,
"slice": [
"y",
"x"
],
"data": "image"
},
"size": [
600,
400
]
},
"CoordinateComponentLink_2": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel y",
"Pixel x"
],
"to": [
"World 1"
],
"pix2world": true,
"coords": "Coordinates"
},
"CoordinateComponentLink": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0",
"World 1"
],
"to": [
"Pixel y"
],
"pix2world": false,
"coords": "Coordinates"
},
"image": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#7f7f7f",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [
"1_0"
],
"_type": "glue.core.data.Data",
"label": "image",
"coords": "Coordinates",
"components": [
[
"image_0",
"Component"
],
[
"Pixel y",
"CoordinateComponent"
],
[
"Pixel x",
"CoordinateComponent_0"
],
[
"World 0",
"CoordinateComponent_1"
],
[
"World 1",
"CoordinateComponent_2"
]
],
"_key_joins": []
},
"World 0": {
"hidden": true,
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"RoiSubsetState": {
"roi": "PolygonalROI",
"_type": "glue.core.subset.RoiSubsetState",
"xatt": "Pixel x",
"yatt": "Pixel y"
},
"Pixel y": {
"hidden": true,
"_type": "glue.core.component_id.ComponentID",
"label": "Pixel y"
},
"Pixel x": {
"hidden": true,
"_type": "glue.core.component_id.ComponentID",
"label": "Pixel x"
},
"PolygonalROI": {
"vx": [
0.523465703971119,
0.523465703971119,
0.523465703971119,
0.523465703971119,
0.5451263537906135,
0.5776173285198554,
0.6642599277978336,
0.8158844765342956,
0.9675090252707577,
1.1841155234657035,
1.335740072202166,
1.4765342960288805,
1.5631768953068592,
1.628158844765343,
1.7039711191335734,
1.7039711191335734,
1.7039711191335734,
1.6931407942238268,
1.628158844765343,
1.5415162454873643,
1.454873646209386,
1.3574007220216604,
1.2599277978339347,
1.162454873646209,
1.0649819494584833,
0.9675090252707577,
0.8808664259927794,
0.7942238267148012,
0.707581227436823,
0.6425992779783392,
0.5992779783393498
],
"vy": [
1.9765342960288808,
1.9548736462093863,
1.868231046931408,
1.7382671480144405,
1.5108303249097472,
1.4133574007220215,
1.2942238267148014,
1.2075812274368232,
1.1859205776173285,
1.1859205776173285,
1.1859205776173285,
1.2075812274368232,
1.2184115523465704,
1.2509025270758123,
1.3375451263537905,
1.4891696750902528,
1.7707581227436824,
2.0090252707581224,
2.279783393501805,
2.4530685920577615,
2.5288808664259927,
2.583032490974729,
2.6263537906137184,
2.6696750902527073,
2.723826714801444,
2.734657039711191,
2.734657039711191,
2.6805054151624548,
2.6046931407942235,
2.5288808664259927,
2.4422382671480145
],
"_type": "glue.core.roi.PolygonalROI"
},
"CoordinateComponentLink_1": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel y",
"Pixel x"
],
"to": [
"World 0"
],
"pix2world": true,
"coords": "Coordinates"
},
"CoordinateComponentLink_0": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0",
"World 1"
],
"to": [
"Pixel x"
],
"pix2world": false,
"coords": "Coordinates"
},
"DS9Normalize": {
"vmax": 1.0,
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"vmin": 1.0,
"clip_hi": 95.0,
"stretch": "arcsinh",
"clip_lo": 5.0,
"contrast": 1.0
},
"DataCollection": {
"_type": "glue.core.data_collection.DataCollection",
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2"
],
"_protocol": 2,
"groups": [
"1"
],
"cids": [
"image_0",
"Pixel y",
"Pixel x",
"World 0",
"World 1"
],
"data": [
"image"
]
},
"Session": {
"_type": "glue.core.session.Session"
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/simple_table_015.glu 0000644 0001750 0001750 00000006415 13610101121 023141 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 2
},
"Component_0": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 3
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 4,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"components": [
"CoordinateComponent",
"CoordinateComponent_0",
"Component",
"Component_0"
],
"data": [
"single_table[HDU1]"
],
"groups": [],
"links": [],
"subset_group_count": 0
},
"LoadLog": {
"_protocol": 1,
"_type": "glue.core.data_factories.helpers.LoadLog",
"factory": {
"_type": "types.FunctionType",
"function": "glue.core.data_factories.fits.fits_reader"
},
"kwargs": [
[]
],
"path": "{DATA_PATH}/single_table.fits"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.viewers.profile.qt",
"glue.core.data_exporters",
"glue.io.formats.fits",
"glue.plugins.data_factories.spectral_cube",
"glue.plugins.tools.pv_slicer",
"glue.viewers.histogram.qt",
"glue.plugins.coordinate_helpers",
"glue.viewers.image.qt",
"glue.plugins.export_d3po",
"glue.plugins.tools",
"glue.viewers.scatter.qt",
"glue.plugins.wcs_autolinking",
"glue.plugins.dendro_viewer.qt",
"glue.viewers.table.qt"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"label": "b"
},
"single_table[HDU1]": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"a",
"Component"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "single_table[HDU1]",
"meta": {
"_type": "collections.OrderedDict",
"contents": {}
},
"primary_owner": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#595959",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "d804c55e-ebee-4850-a0f1-3b854bda62b4"
}
}
glueviz-1.0.1+dfsg.orig/glue/tests/data/session_coordinate_links_013.glu 0000644 0001750 0001750 00000017004 13503203504 025576 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
},
"units": ""
},
"ComponentLink": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"x_0",
"y_0"
],
"inverse": null,
"to": [
"x"
],
"using": {
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"_type": "types.MethodType",
"instance": "Galactic_to_FK5",
"method": "forward"
},
"index": 0
}
},
"ComponentLink_0": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"x",
"y"
],
"inverse": null,
"to": [
"x_0"
],
"using": {
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"_type": "types.MethodType",
"instance": "Galactic_to_FK5",
"method": "backward"
},
"index": 0
}
},
"ComponentLink_1": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"x_0",
"y_0"
],
"inverse": null,
"to": [
"y"
],
"using": {
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"_type": "types.MethodType",
"instance": "Galactic_to_FK5",
"method": "forward"
},
"index": 1
}
},
"ComponentLink_2": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"x",
"y"
],
"inverse": null,
"to": [
"y_0"
],
"using": {
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"_type": "types.MethodType",
"instance": "Galactic_to_FK5",
"method": "backward"
},
"index": 1
}
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoCAAAAAAAAAAMAAAAAAAAABAAAAAAAAAA="
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
},
"units": ""
},
"Component_2": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoCAAAAAAAAAAMAAAAAAAAABAAAAAAAAAA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 4,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"Pixel Axis 0 [x]",
"World 0",
"x",
"y",
"Pixel Axis 0 [x]_0",
"World 0_0",
"x_0",
"y_0"
],
"components": [
"CoordinateComponent",
"CoordinateComponent_0",
"Component",
"Component_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"Component_1",
"Component_2"
],
"data": [
"data1",
"data2"
],
"groups": [],
"links": [
"ComponentLink",
"ComponentLink_0",
"ComponentLink_1",
"ComponentLink_2"
],
"subset_group_count": 0
},
"Galactic_to_FK5": {
"_type": "glue.plugins.coordinate_helpers.link_helpers.Galactic_to_FK5",
"cids": [
"x_0",
"y_0",
"x",
"y"
]
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"label": "Pixel Axis 0 [x]"
},
"Pixel Axis 0 [x]_0": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"World 0_0": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.tools",
"glue.plugins.export_d3po",
"glue.core.data_exporters",
"mosviz",
"glue.io.formats.fits",
"glue.plugins.tools.pv_slicer",
"glue.plugins.coordinate_helpers",
"glue.plugins.data_factories.spectral_cube"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[]
]
},
"data1": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"x",
"Component"
],
[
"y",
"Component_0"
]
],
"coords": "Coordinates",
"label": "data1",
"meta": {
"_type": "collections.OrderedDict",
"contents": {}
},
"primary_owner": [
"Pixel Axis 0 [x]",
"World 0",
"x",
"y"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#919191",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "4eb0477a-dc4c-4062-8245-4249124f66b0"
},
"data2": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [x]_0",
"CoordinateComponent_1"
],
[
"World 0_0",
"CoordinateComponent_2"
],
[
"x_0",
"Component_1"
],
[
"y_0",
"Component_2"
]
],
"coords": "Coordinates_0",
"label": "data2",
"meta": {
"_type": "collections.OrderedDict",
"contents": {}
},
"primary_owner": [
"Pixel Axis 0 [x]_0",
"World 0_0",
"x_0",
"y_0"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#919191",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "a0d5cba0-9770-4b38-8682-82c80854b109"
},
"x": {
"_type": "glue.core.component_id.ComponentID",
"label": "x"
},
"x_0": {
"_type": "glue.core.component_id.ComponentID",
"label": "x"
},
"y": {
"_type": "glue.core.component_id.ComponentID",
"label": "y"
},
"y_0": {
"_type": "glue.core.component_id.ComponentID",
"label": "y"
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/__init__.py 0000644 0001750 0001750 00000000000 13455362716 021526 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/tests/data/load_log_1.glu 0000644 0001750 0001750 00000006451 13502206677 022142 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 2
},
"Component_0": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 3
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"components": [
"CoordinateComponent",
"CoordinateComponent_0",
"Component",
"Component_0"
],
"data": [
"simple"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0"
],
"subset_group_count": 0
},
"LoadLog": {
"_protocol": 1,
"_type": "glue.core.data_factories.helpers.LoadLog",
"factory": {
"_type": "types.FunctionType",
"function": "glue.core.data_factories.helpers.auto_data"
},
"kwargs": [
[]
],
"path": "{DATA_PATH}simple.csv"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"simple": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"a",
"Component"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "simple",
"primary_owner": [
"Pixel Axis 0 [x]",
"World 0",
"a",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "741368cc-0826-4e8e-aa11-9e8ac0a093cd"
}
}
glueviz-1.0.1+dfsg.orig/glue/tests/data/simple_hdf5_grid.glu 0000644 0001750 0001750 00000025116 13455362716 023351 0 ustar noahfx noahfx {
"CoordinateComponent_9": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"CoordinateComponent_8": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"World 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"World 2": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 2"
},
"World 1": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 1"
},
"CoordinateComponent_0": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"single_grid": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "single_grid",
"coords": "Coordinates",
"components": [
[
"/array1_0",
"Component_0"
],
[
"Pixel z_0",
"CoordinateComponent_5"
],
[
"Pixel y_0",
"CoordinateComponent_6"
],
[
"Pixel x_0",
"CoordinateComponent_7"
],
[
"World 0_0",
"CoordinateComponent_8"
],
[
"World 1_0",
"CoordinateComponent_9"
],
[
"World 2_0",
"CoordinateComponent_10"
]
],
"_key_joins": []
},
"CoordinateComponent_6": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"CoordinateComponent_5": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_4": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 2
},
"World 1_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 1"
},
"CoordinateComponentLink_6": {
"index": 2,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0",
"World 1",
"World 2"
],
"to": [
"Pixel x"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_10": {
"index": 2,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0",
"World 1_0",
"World 2_0"
],
"to": [
"Pixel x_0"
],
"pix2world": false,
"coords": "Coordinates"
},
"__main__": {
"_type": "glue.qt.glue_application.GlueApplication",
"session": "Session",
"data": "DataCollection",
"viewers": [
[]
]
},
"CoordinateComponentLink_2": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0",
"World 1",
"World 2"
],
"to": [
"Pixel y"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"Pixel x_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel x"
},
"World 2_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 2"
},
"Component": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog"
},
"Pixel y_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel y"
},
"CoordinateComponent_3": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"Pixel z_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel z"
},
"CoordinateComponentLink": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0",
"World 1",
"World 2"
],
"to": [
"Pixel z"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"/array1_0": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "/array1"
},
"CoordinateComponent_2": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_10": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 2
},
"CoordinateComponent_1": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 2
},
"CoordinateComponentLink_9": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z",
"Pixel y",
"Pixel x"
],
"to": [
"World 0"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"World 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"Pixel z": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel z"
},
"Pixel y": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel y"
},
"Pixel x": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel x"
},
"CoordinateComponentLink_3": {
"index": 2,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z_0",
"Pixel y_0",
"Pixel x_0"
],
"to": [
"World 2_0"
],
"pix2world": true,
"coords": "Coordinates"
},
"CoordinateComponent_7": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 2
},
"CoordinateComponentLink_1": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0",
"World 1_0",
"World 2_0"
],
"to": [
"Pixel z_0"
],
"pix2world": false,
"coords": "Coordinates"
},
"CoordinateComponentLink_0": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z",
"Pixel y",
"Pixel x"
],
"to": [
"World 1"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_7": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z_0",
"Pixel y_0",
"Pixel x_0"
],
"to": [
"World 1_0"
],
"pix2world": true,
"coords": "Coordinates"
},
"LoadLog": {
"path": "{DATA_PATH}single_grid.hdf5",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.auto_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
},
"CoordinateComponentLink_5": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z_0",
"Pixel y_0",
"Pixel x_0"
],
"to": [
"World 0_0"
],
"pix2world": true,
"coords": "Coordinates"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"CoordinateComponent": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponentLink_4": {
"index": 2,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel z",
"Pixel y",
"Pixel x"
],
"to": [
"World 2"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_8": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0",
"World 1_0",
"World 2_0"
],
"to": [
"Pixel y_0"
],
"pix2world": false,
"coords": "Coordinates"
},
"/array1": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "/array1"
},
"Component_0": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog_0"
},
"DataCollection": {
"_type": "glue.core.data_collection.DataCollection",
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"CoordinateComponent_3",
"CoordinateComponent_4",
"Component_0",
"CoordinateComponent_5",
"CoordinateComponent_6",
"CoordinateComponent_7",
"CoordinateComponent_8",
"CoordinateComponent_9",
"CoordinateComponent_10"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6",
"CoordinateComponentLink_7",
"CoordinateComponentLink_8",
"CoordinateComponentLink_9",
"CoordinateComponentLink_10"
],
"_protocol": 2,
"groups": [],
"cids": [
"/array1",
"Pixel z",
"Pixel y",
"Pixel x",
"World 0",
"World 1",
"World 2",
"/array1_0",
"Pixel z_0",
"Pixel y_0",
"Pixel x_0",
"World 0_0",
"World 1_0",
"World 2_0"
],
"data": [
"single_grid_auto",
"single_grid"
]
},
"Session": {
"_type": "glue.core.session.Session"
},
"LoadLog_0": {
"path": "{DATA_PATH}single_grid.hdf5",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.gridded_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
},
"single_grid_auto": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5019607843137255,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "single_grid_auto",
"coords": "Coordinates_0",
"components": [
[
"/array1",
"Component"
],
[
"Pixel z",
"CoordinateComponent"
],
[
"Pixel y",
"CoordinateComponent_0"
],
[
"Pixel x",
"CoordinateComponent_1"
],
[
"World 0",
"CoordinateComponent_2"
],
[
"World 1",
"CoordinateComponent_3"
],
[
"World 2",
"CoordinateComponent_4"
]
],
"_key_joins": []
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/simple_tables.glu 0000644 0001750 0001750 00000026154 13455362716 022773 0 ustar noahfx noahfx {
"LoadLog": {
"path": "{DATA_PATH}single_table.fits",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.auto_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
},
"a_2": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "a"
},
"a_1": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "a"
},
"a_0": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "a"
},
"World 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"World 0_1": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"World 0_2": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"World 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"Coordinates_1": {
"_type": "glue.core.coordinates.Coordinates"
},
"CoordinateComponent_6": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_5": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_4": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"__main__": {
"_type": "glue.qt.glue_application.GlueApplication",
"session": "Session",
"data": "DataCollection",
"viewers": [
[]
]
},
"b_0": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"b_1": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"b_2": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"double_tables": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "double_tables",
"coords": "Coordinates",
"components": [
[
"a_2",
"Component_5"
],
[
"Pixel Axis 0_2",
"CoordinateComponent_5"
],
[
"World 0_2",
"CoordinateComponent_6"
],
[
"b_2",
"Component_6"
]
],
"_key_joins": []
},
"Component": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog"
},
"single_table": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "single_table",
"coords": "Coordinates_0",
"components": [
[
"a_0",
"Component_1"
],
[
"Pixel Axis 0_0",
"CoordinateComponent_1"
],
[
"World 0_0",
"CoordinateComponent_2"
],
[
"b_0",
"Component_2"
]
],
"_key_joins": []
},
"CoordinateComponent_3": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponentLink": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_2"
],
"to": [
"Pixel Axis 0_2"
],
"pix2world": false,
"coords": "Coordinates"
},
"CoordinateComponent_2": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_1": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"single_table_auto": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5019607843137255,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "single_table_auto",
"coords": "Coordinates_1",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"_key_joins": []
},
"CoordinateComponent_0": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"Pixel Axis 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"Pixel Axis 0_1": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"Pixel Axis 0_2": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"Pixel Axis 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"CoordinateComponentLink_3": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0"
],
"to": [
"Pixel Axis 0"
],
"pix2world": false,
"coords": "Coordinates_1"
},
"CoordinateComponentLink_2": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0"
],
"to": [
"World 0"
],
"pix2world": true,
"coords": "Coordinates_1"
},
"CoordinateComponentLink_1": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0_0"
],
"to": [
"World 0_0"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_0": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0_1"
],
"to": [
"World 0_1"
],
"pix2world": true,
"coords": "Coordinates_2"
},
"CoordinateComponentLink_6": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_1"
],
"to": [
"Pixel Axis 0_1"
],
"pix2world": false,
"coords": "Coordinates_2"
},
"CoordinateComponentLink_5": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0"
],
"to": [
"Pixel Axis 0_0"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates_2": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"CoordinateComponent": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponentLink_4": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0_2"
],
"to": [
"World 0_2"
],
"pix2world": true,
"coords": "Coordinates"
},
"a": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "a"
},
"b": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"double_tables_auto": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5019607843137255,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "double_tables_auto",
"coords": "Coordinates_2",
"components": [
[
"a_1",
"Component_3"
],
[
"Pixel Axis 0_1",
"CoordinateComponent_3"
],
[
"World 0_1",
"CoordinateComponent_4"
],
[
"b_1",
"Component_4"
]
],
"_key_joins": []
},
"Component_3": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog_0"
},
"Component_2": {
"log_item": 3,
"_type": "glue.core.data.Component",
"log": "LoadLog_1"
},
"Component_1": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog_1"
},
"Component_0": {
"log_item": 3,
"_type": "glue.core.data.Component",
"log": "LoadLog"
},
"Component_6": {
"log_item": 3,
"_type": "glue.core.data.Component",
"log": "LoadLog_2"
},
"Component_5": {
"log_item": 0,
"_type": "glue.core.data.Component",
"log": "LoadLog_2"
},
"Component_4": {
"log_item": 3,
"_type": "glue.core.data.Component",
"log": "LoadLog_0"
},
"DataCollection": {
"_type": "glue.core.data_collection.DataCollection",
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0",
"Component_1",
"CoordinateComponent_1",
"CoordinateComponent_2",
"Component_2",
"Component_3",
"CoordinateComponent_3",
"CoordinateComponent_4",
"Component_4",
"Component_5",
"CoordinateComponent_5",
"CoordinateComponent_6",
"Component_6"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6"
],
"_protocol": 2,
"groups": [],
"cids": [
"a",
"Pixel Axis 0",
"World 0",
"b",
"a_0",
"Pixel Axis 0_0",
"World 0_0",
"b_0",
"a_1",
"Pixel Axis 0_1",
"World 0_1",
"b_1",
"a_2",
"Pixel Axis 0_2",
"World 0_2",
"b_2"
],
"data": [
"single_table_auto",
"single_table",
"double_tables_auto",
"double_tables"
]
},
"Session": {
"_type": "glue.core.session.Session"
},
"LoadLog_2": {
"path": "{DATA_PATH}double_tables.fits",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.astropy_tabular_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
},
"LoadLog_0": {
"path": "{DATA_PATH}double_tables.fits",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.auto_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
},
"LoadLog_1": {
"path": "{DATA_PATH}single_table.fits",
"_type": "glue.core.data_factories.LoadLog",
"factory": {
"function": "glue.core.data_factories.astropy_tabular_data",
"_type": "types.FunctionType"
},
"kwargs": [
[]
]
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/simple.csv 0000644 0001750 0001750 00000000020 13502206677 021421 0 ustar noahfx noahfx a,b
1,2
3,2
5,3
glueviz-1.0.1+dfsg.orig/glue/tests/data/session_links.glu 0000644 0001750 0001750 00000023353 13455362716 023031 0 ustar noahfx noahfx {
"World 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"CoordinateComponent_2": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_1": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"CoordinateComponent_0": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DerivedComponent": {
"_type": "glue.core.data.DerivedComponent",
"link": "ComponentLink"
},
"__main__": {
"_type": "glue.qt.glue_application.GlueApplication",
"session": "Session",
"data": "DataCollection",
"viewers": [
[]
]
},
"DerivedComponent_2": {
"_type": "glue.core.data.DerivedComponent",
"link": "ComponentLink_2"
},
"DerivedComponent_1": {
"_type": "glue.core.data.DerivedComponent",
"link": "ComponentLink_0"
},
"DerivedComponent_0": {
"_type": "glue.core.data.DerivedComponent",
"link": "ComponentLink_1"
},
"CoordinateComponent": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"ComponentLink": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"l",
"b"
],
"to": [
"ra"
],
"using": {
"index": 0,
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"function": "glue.external.aplpy.gal2fk5",
"_type": "types.FunctionType"
}
},
"hidden": false
},
"CoordinateComponentLink": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0_0"
],
"to": [
"World 0_0"
],
"pix2world": true,
"coords": "Coordinates"
},
"ra": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "ra"
},
"ComponentLink_2": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"ra",
"dec"
],
"to": [
"b"
],
"using": {
"function": "glue.core.link_helpers.radec2glat",
"_type": "types.FunctionType"
},
"hidden": false
},
"ComponentLink_1": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"l",
"b"
],
"to": [
"dec"
],
"using": {
"index": 1,
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"function": "glue.external.aplpy.gal2fk5",
"_type": "types.FunctionType"
}
},
"hidden": false
},
"World 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"Pixel Axis 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"Pixel Axis 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"ComponentLink_3": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"l",
"b"
],
"to": [
"dec"
],
"using": {
"function": "glue.core.link_helpers.lb2dec",
"_type": "types.FunctionType"
},
"hidden": false
},
"CoordinateComponentLink_2": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0"
],
"to": [
"World 0"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_1": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0"
],
"to": [
"Pixel Axis 0"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"Component": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
}
},
"ComponentLink_6": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"l",
"b"
],
"to": [
"ra"
],
"using": {
"function": "glue.core.link_helpers.lb2ra",
"_type": "types.FunctionType"
},
"hidden": false
},
"ComponentLink_5": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"ra",
"dec"
],
"to": [
"b"
],
"using": {
"index": 1,
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"function": "glue.external.aplpy.fk52gal",
"_type": "types.FunctionType"
}
},
"hidden": false
},
"ComponentLink_4": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"ra",
"dec"
],
"to": [
"l"
],
"using": {
"index": 0,
"_type": "glue.core.link_helpers.PartialResult",
"func": {
"function": "glue.external.aplpy.fk52gal",
"_type": "types.FunctionType"
}
},
"hidden": false
},
"CoordinateComponentLink_0": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0"
],
"to": [
"Pixel Axis 0_0"
],
"pix2world": false,
"coords": "Coordinates"
},
"b": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"Component_2": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
}
},
"Component_1": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
}
},
"Component_0": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
}
},
"t2": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "t2",
"coords": "Coordinates_0",
"components": [
[
"b",
"Component"
],
[
"Pixel Axis 0",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"l",
"Component_0"
],
[
"ra",
"DerivedComponent"
],
[
"dec",
"DerivedComponent_0"
]
],
"_key_joins": []
},
"l": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "l"
},
"t1": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "t1",
"coords": "Coordinates",
"components": [
[
"dec",
"Component_1"
],
[
"Pixel Axis 0_0",
"CoordinateComponent_1"
],
[
"World 0_0",
"CoordinateComponent_2"
],
[
"ra",
"Component_2"
],
[
"l",
"DerivedComponent_1"
],
[
"b",
"DerivedComponent_2"
]
],
"_key_joins": []
},
"DataCollection": {
"_type": "glue.core.data_collection.DataCollection",
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0",
"DerivedComponent",
"DerivedComponent_0",
"Component_1",
"CoordinateComponent_1",
"CoordinateComponent_2",
"Component_2",
"DerivedComponent_1",
"DerivedComponent_2"
],
"links": [
"ComponentLink",
"ComponentLink_0",
"ComponentLink_1",
"CoordinateComponentLink",
"ComponentLink_2",
"CoordinateComponentLink_0",
"ComponentLink_3",
"ComponentLink_4",
"ComponentLink_5",
"CoordinateComponentLink_1",
"ComponentLink_6",
"CoordinateComponentLink_2"
],
"_protocol": 2,
"groups": [],
"cids": [
"b",
"Pixel Axis 0",
"World 0",
"l",
"ra",
"dec",
"dec",
"Pixel Axis 0_0",
"World 0_0",
"ra",
"l",
"b"
],
"data": [
"t2",
"t1"
]
},
"Session": {
"_type": "glue.core.session.Session"
},
"dec": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "dec"
},
"ComponentLink_0": {
"_type": "glue.core.component_link.ComponentLink",
"inverse": null,
"frm": [
"ra",
"dec"
],
"to": [
"l"
],
"using": {
"function": "glue.core.link_helpers.radec2glon",
"_type": "types.FunctionType"
},
"hidden": false
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/load_log_0.glu 0000644 0001750 0001750 00000006425 13502206677 022142 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 0
},
"Component_0": {
"_type": "glue.core.component.Component",
"log": "LoadLog",
"log_item": 3
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0"
],
"data": [
"simple"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0"
],
"subset_group_count": 0
},
"LoadLog": {
"_type": "glue.core.data_factories.helpers.LoadLog",
"factory": {
"_type": "types.FunctionType",
"function": "glue.core.data_factories.helpers.auto_data"
},
"kwargs": [
[]
],
"path": "{DATA_PATH}simple.csv"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"simple": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "simple",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "fd317c94-7a6a-4ac2-b024-17e44bde3cb8"
}
}
glueviz-1.0.1+dfsg.orig/glue/tests/data/simple_viewers.glu 0000644 0001750 0001750 00000022177 13455362716 023206 0 ustar noahfx noahfx {
"ScatterWidget": {
"layers": [
{
"_type": "glue.clients.layer_artist.ScatterLayerArtist",
"layer": "table",
"yatt": "a",
"visible": true,
"zorder": 1,
"xatt": "b"
}
],
"_type": "glue.qt.widgets.scatter_widget.ScatterWidget",
"pos": [
0,
0
],
"session": "Session",
"properties": {
"xflip": false,
"ymax": 3.04,
"xlog": true,
"yflip": true,
"yatt": "a",
"ylog": false,
"xmax": 4.36,
"xmin": 1.24,
"hidden": false,
"ymin": 0.96,
"xatt": "b"
},
"size": [
670,
512
]
},
"World 0_0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"CoordinateComponent_2": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"image": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "image",
"coords": "Coordinates",
"components": [
[
"image_0",
"Component_1"
],
[
"Pixel y",
"CoordinateComponent_1"
],
[
"Pixel x",
"CoordinateComponent_2"
],
[
"World 0_0",
"CoordinateComponent_3"
],
[
"World 1",
"CoordinateComponent_4"
]
],
"_key_joins": []
},
"World 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 0"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"CoordinateComponent_4": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 1
},
"__main__": {
"_type": "glue.qt.glue_application.GlueApplication",
"session": "Session",
"data": "DataCollection",
"viewers": [
[
"ScatterWidget",
"ImageWidget",
"HistogramWidget"
]
]
},
"table": {
"style": {
"_type": "glue.core.visual.VisualAttributes",
"color": "#373737",
"markersize": 3,
"marker": "o",
"alpha": 0.5,
"linewidth": 1,
"linestyle": "solid"
},
"_protocol": 3,
"subsets": [],
"_type": "glue.core.data.Data",
"label": "table",
"coords": "Coordinates_0",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"_key_joins": []
},
"image_0": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "image"
},
"CoordinateComponent": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"Pixel x": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel x"
},
"Component": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
}
},
"CoordinateComponent_3": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"ImageWidget": {
"layers": [
{
"visible": true,
"layer": "image",
"zorder": 1,
"_type": "glue.clients.layer_artist.ImageLayerArtist",
"norm": "DS9Normalize"
}
],
"_type": "glue.qt.widgets.image_widget.ImageWidget",
"pos": [
672,
0
],
"session": "Session",
"properties": {
"rgb_viz": [
true,
true,
true
],
"ratt": null,
"rgb_mode": false,
"gatt": null,
"attribute": "image_0",
"batt": null,
"slice": [
"y",
"x"
],
"data": "image"
},
"size": [
562,
513
]
},
"CoordinateComponentLink": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0",
"World 1"
],
"to": [
"Pixel y"
],
"pix2world": false,
"coords": "Coordinates"
},
"World 1": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "World 1"
},
"CoordinateComponent_0": {
"world": true,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"HistogramWidget": {
"layers": [
{
"nbins": 5.0,
"layer": "table",
"lo": 1.3,
"xlog": false,
"_type": "glue.clients.layer_artist.HistogramLayerArtist",
"visible": true,
"hi": 4.2999999999999998,
"zorder": 1
}
],
"_type": "glue.qt.widgets.histogram_widget.HistogramWidget",
"pos": [
0,
535
],
"session": "Session",
"properties": {
"nbins": 5.0,
"normed": false,
"autoscale": true,
"xlog": false,
"cumulative": false,
"component": "b",
"ylog": false,
"xmax": 4.3,
"xmin": 1.3
},
"size": [
1235,
531
]
},
"Pixel y": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel y"
},
"Pixel Axis 0": {
"hidden": true,
"_type": "glue.core.data.ComponentID",
"label": "Pixel Axis 0"
},
"CoordinateComponentLink_3": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel y",
"Pixel x"
],
"to": [
"World 1"
],
"pix2world": true,
"coords": "Coordinates"
},
"CoordinateComponentLink_2": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0"
],
"to": [
"Pixel Axis 0"
],
"pix2world": false,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_1": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel y",
"Pixel x"
],
"to": [
"World 0_0"
],
"pix2world": true,
"coords": "Coordinates"
},
"CoordinateComponentLink_0": {
"index": 0,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"Pixel Axis 0"
],
"to": [
"World 0"
],
"pix2world": true,
"coords": "Coordinates_0"
},
"CoordinateComponentLink_4": {
"index": 1,
"_type": "glue.core.component_link.CoordinateComponentLink",
"frm": [
"World 0_0",
"World 1"
],
"to": [
"Pixel x"
],
"pix2world": false,
"coords": "Coordinates"
},
"a": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "a"
},
"b": {
"hidden": false,
"_type": "glue.core.data.ComponentID",
"label": "b"
},
"CoordinateComponent_1": {
"world": false,
"_type": "glue.core.data.CoordinateComponent",
"axis": 0
},
"Component_1": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsIDMpLCB9ICAgICAgICAgIAooXatr9N7uP2BEXHn4oZo/A7ENS98v7D9I5JtTwmHEP3ajNj9M198/ZE5h+Z+Nzz9wEO/ZkuqlP94MlPisMuQ/G94dgwMP6j8="
}
},
"Component_0": {
"units": null,
"_type": "glue.core.data.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIArNzMzMzMz0P83MzMzMzARAMzMzMzMzEUA="
}
},
"DS9Normalize": {
"vmax": 0.93116720658359486,
"_type": "glue.clients.ds9norm.DS9Normalize",
"bias": 0.5,
"vmin": 0.032727208219196571,
"clip_hi": 95.0,
"stretch": "arcsinh",
"clip_lo": 5.0,
"contrast": 1.0
},
"DataCollection": {
"_type": "glue.core.data_collection.DataCollection",
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0",
"Component_1",
"CoordinateComponent_1",
"CoordinateComponent_2",
"CoordinateComponent_3",
"CoordinateComponent_4"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4"
],
"_protocol": 2,
"groups": [],
"cids": [
"a",
"Pixel Axis 0",
"World 0",
"b",
"image_0",
"Pixel y",
"Pixel x",
"World 0_0",
"World 1"
],
"data": [
"table",
"image"
]
},
"Session": {
"_type": "glue.core.session.Session"
}
} glueviz-1.0.1+dfsg.orig/glue/tests/data/glue_v0.10_table.glu 0000644 0001750 0001750 00000020075 13502206677 023067 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoEAAAAAAAAAAUAAAAAAAAABgAAAAAAAAA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"Pixel Axis 0 [x]_0"
],
"index": 0,
"pix2world": true,
"to": [
"World 0_0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"World 0_0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]_0"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]_1"
],
"index": 0,
"pix2world": true,
"to": [
"World 0_1"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0_1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]_1"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"x",
"Pixel Axis 0 [x]",
"World 0",
"y"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0"
],
"data": [
"data"
],
"groups": [
"Subset 1_0",
"Subset 2_0"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4"
],
"subset_group_count": 2
},
"ElementSubsetState": {
"_type": "glue.core.subset.ElementSubsetState",
"data_uuid": "ca8ae9d2-170d-482a-bb93-4f8e1b4b1ddd",
"indices": [
0,
1
]
},
"ElementSubsetState_0": {
"_type": "glue.core.subset.ElementSubsetState",
"data_uuid": "ca8ae9d2-170d-482a-bb93-4f8e1b4b1ddd",
"indices": [
1
]
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Pixel Axis 0 [x]_0": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Pixel Axis 0 [x]_1": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 1_0": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "ElementSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1"
]
},
"Subset 2": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 2_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 2_0": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 2",
"state": "ElementSubsetState_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 2"
]
},
"TableWidget": {
"_type": "glue.viewers.table.qt.viewer_widget.TableWidget",
"layers": [
{
"_type": "glue.viewers.table.qt.viewer_widget.TableLayerArtist",
"layer": "data",
"visible": true,
"zorder": 1
},
{
"_type": "glue.viewers.table.qt.viewer_widget.TableLayerArtist",
"layer": "Subset 1",
"visible": true,
"zorder": 2
},
{
"_type": "glue.viewers.table.qt.viewer_widget.TableLayerArtist",
"layer": "Subset 2",
"visible": true,
"zorder": 3
}
],
"pos": [
0,
0
],
"properties": {},
"session": "Session",
"size": [
640,
480
]
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 0_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 0_1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.tools.pv_slicer",
"glue_vispy_viewers.scatter",
"glue_vispy_viewers.volume",
"glue.core.data_exporters",
"glue.plugins.tools.spectrum_tool",
"glue.viewers.table",
"glue.plugins.coordinate_helpers",
"glue.plugins.exporters.plotly",
"glue.viewers.image",
"glue.viewers.histogram",
"glue.viewers.scatter",
"glue_ginga",
"glue.plugins.export_d3po"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"TableWidget"
]
]
},
"data": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"x",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"y",
"Component_0"
]
],
"coords": "Coordinates",
"label": "data",
"primary_owner": [
"x",
"Pixel Axis 0 [x]",
"World 0",
"y"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#595959",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1",
"Subset 2"
],
"uuid": "ca8ae9d2-170d-482a-bb93-4f8e1b4b1ddd"
},
"x": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "x"
},
"y": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "y"
}
} glueviz-1.0.1+dfsg.orig/glue/tests/test_config.py 0000644 0001750 0001750 00000001615 13605357235 021374 0 ustar noahfx noahfx from ..config import qt_client, link_function, data_factory
from glue.tests.helpers import requires_qt
@requires_qt
def test_default_clients():
from glue.viewers.image.qt import ImageViewer
from glue.viewers.scatter.qt import ScatterViewer
from glue.viewers.histogram.qt import HistogramViewer
assert ImageViewer in qt_client
assert ScatterViewer in qt_client
assert HistogramViewer in qt_client
def test_add_client():
@qt_client
class TestClient(object):
pass
assert TestClient in qt_client
def test_add_link_default():
@link_function(info='maps x to y', output_labels=['y'])
def foo(x):
return 3
val = (foo, 'maps x to y', ['y'], 'General')
assert val in link_function
def test_add_data_factory():
@data_factory('XYZ file', "*txt")
def foo(x):
pass
assert (foo, 'XYZ file', '*txt', 0, False) in data_factory
glueviz-1.0.1+dfsg.orig/glue/tests/test_settings_helpers.py 0000644 0001750 0001750 00000003410 13605357235 023504 0 ustar noahfx noahfx from unittest.mock import patch
import os
from glue.config import SettingRegistry
from glue._settings_helpers import load_settings, save_settings
def test_roundtrip(tmpdir):
settings = SettingRegistry()
settings.add('STRING', 'green', str)
settings.add('INT', 3, int)
settings.add('FLOAT', 5.5, float)
settings.add('LIST', [1, 2, 3], list)
with patch('glue.config.settings', settings):
with patch('glue.config.CFG_DIR', tmpdir.strpath):
settings.STRING = 'blue'
settings.INT = 4
settings.FLOAT = 3.5
settings.LIST = ['A', 'BB', 'CCC']
settings.reset_defaults()
assert settings.STRING == 'green'
assert settings.INT == 3
assert settings.FLOAT == 5.5
assert settings.LIST == [1, 2, 3]
settings.STRING = 'blue'
settings.INT = 4
settings.FLOAT = 3.5
settings.LIST = ['A', 'BB', 'CCC']
save_settings()
assert os.path.exists(os.path.join(tmpdir.strpath, 'settings.cfg'))
settings.reset_defaults()
settings.STRING = 'red'
settings.INT = 5
# Loading settings will only change settings that have not been
# changed from the defaults...
load_settings()
assert settings.STRING == 'red'
assert settings.INT == 5
assert settings.FLOAT == 3.5
assert settings.LIST == ['A', 'BB', 'CCC']
# ... unless the ``force=True`` option is passed
load_settings(force=True)
assert settings.STRING == 'blue'
assert settings.INT == 4
assert settings.FLOAT == 3.5
assert settings.LIST == ['A', 'BB', 'CCC']
glueviz-1.0.1+dfsg.orig/glue/tests/test_qglue.py 0000644 0001750 0001750 00000017645 13605357235 021256 0 ustar noahfx noahfx import pytest
import numpy as np
import pandas as pd
from unittest.mock import patch
from .. import qglue
from ..core import BaseCartesianData, Data
from ..core.exceptions import IncompatibleAttribute
from ..core.registry import Registry
from .helpers import requires_astropy, requires_qt
@requires_qt
@requires_astropy
class TestQGlue(object):
def setup_method(self, method):
from astropy.table import Table
from astropy.io.fits import HDUList, ImageHDU
Registry().clear()
x = [1, 2, 3]
y = [2, 3, 4]
u = [10, 20, 30, 40]
v = [20, 40, 60, 80]
self.xy = {'x': x, 'y': y}
self.dict_data = {'u': u, 'v': v}
self.recarray_data = np.rec.array([(0, 1), (2, 3)],
dtype=[(str('a'), int), (str('b'), int)])
self.astropy_table = Table({'x': x, 'y': y})
self.bad_data = {'x': x, 'u': u}
self.hdulist = HDUList([ImageHDU(x, name='PRIMARY')])
self.x = np.array(x)
self.y = np.array(y)
self.u = np.array(u)
self.v = np.array(v)
def check_setup(self, dc, expected):
# assert that the assembled data collection returned
# form qglue matches expected structure
# test for expected data, components
for data in dc:
components = set(c.label for c in data.components)
e = expected.pop(data.label)
for component in e:
assert component in components
assert len(expected) == 0
def test_qglue_starts_application(self):
pandas_data = pd.DataFrame(self.xy)
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=pandas_data)
ga.assert_called_once()
def test_single_pandas(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=self.xy)
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['x', 'y']})
def test_single_pandas_nonstring_column(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=pd.DataFrame({1: [1, 2, 3]}))
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['1']})
def test_single_numpy(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=np.array([1, 2, 3]))
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['data1']})
def test_single_list(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=[1, 2, 3])
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['data1']})
def test_single_dict(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data2=self.dict_data)
dc = ga.call_args[0][0]
self.check_setup(dc, {'data2': ['u', 'v']})
def test_recarray(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data3=self.recarray_data)
dc = ga.call_args[0][0]
self.check_setup(dc, {'data3': ['a', 'b']})
def test_astropy_table(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data4=self.astropy_table)
dc = ga.call_args[0][0]
self.check_setup(dc, {'data4': ['x', 'y']})
def test_multi_data(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=self.dict_data, data2=self.xy)
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['u', 'v'],
'data2': ['x', 'y']})
def test_hdulist(self):
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=self.hdulist).data_collection
dc = ga.call_args[0][0]
self.check_setup(dc, {'data1': ['PRIMARY']})
def test_glue_data(self):
d = Data(x=[1, 2, 3])
with patch('glue.app.qt.GlueApplication') as ga:
qglue(x=d)
dc = ga.call_args[0][0]
assert d.label == 'x'
def test_base_data(self):
class CustomData(BaseCartesianData):
def get_kind(self):
pass
def compute_histogram(self):
pass
def compute_statistic(self):
pass
def get_mask(self):
pass
@property
def shape(self):
pass
@property
def main_components(self):
return []
d = CustomData()
with patch('glue.app.qt.GlueApplication') as ga:
qglue(x=d)
dc = ga.call_args[0][0]
assert dc[0] is d
def test_simple_link(self):
using = lambda x: x * 2
links = [['data1.x', 'data2.u', using]]
with patch('glue.app.qt.GlueApplication') as ga:
qglue(data1=self.xy, data2=self.dict_data, links=links)
dc = ga.call_args[0][0]
links = [[['x'], 'u', using]]
self.check_setup(dc, {'data1': ['x', 'y'],
'data2': ['u', 'v']})
d = dc[0] if dc[0].label == 'data1' else dc[1]
np.testing.assert_array_equal(d['x'], self.x)
np.testing.assert_array_equal(d['u'], self.x * 2)
d = dc[0] if dc[0].label == 'data2' else dc[1]
with pytest.raises(IncompatibleAttribute) as exc:
d['x']
def test_multi_link(self):
def forwards(x, y):
return x * 2, y * 3
def backwards(x, y):
return x / 2, y / 3
links = [[['Data1.x', 'Data1.y'],
['Data2.u', 'Data2.v'], forwards, backwards]]
with patch('glue.app.qt.GlueApplication') as ga:
qglue(Data1=self.xy, Data2=self.dict_data, links=links)
dc = ga.call_args[0][0]
self.check_setup(dc, {'Data1': ['x', 'y'],
'Data2': ['u', 'v']})
for d in dc:
if d.label == 'Data1':
np.testing.assert_array_equal(d['x'], self.x)
np.testing.assert_array_equal(d['y'], self.y)
np.testing.assert_array_equal(d['u'], self.x * 2)
np.testing.assert_array_equal(d['v'], self.y * 3)
else:
np.testing.assert_array_equal(d['x'], self.u / 2)
np.testing.assert_array_equal(d['y'], self.v / 3)
np.testing.assert_array_equal(d['u'], self.u)
np.testing.assert_array_equal(d['v'], self.v)
def test_implicit_identity_link(self):
links = [('Data1.x', 'Data2.v'),
('Data1.y', 'Data2.u')]
with patch('glue.app.qt.GlueApplication') as ga:
qglue(Data1=self.xy, Data2=self.dict_data, links=links)
dc = ga.call_args[0][0]
# currently, identity links rename the second link to first,
# so u/v disappear
for d in dc:
if d.label == 'Data1':
np.testing.assert_array_equal(d['x'], self.x)
np.testing.assert_array_equal(d['y'], self.y)
else:
np.testing.assert_array_equal(d['y'], self.u)
np.testing.assert_array_equal(d['x'], self.v)
def test_bad_link(self):
forwards = lambda *args: args
links = [(['Data1.a'], ['Data2.b'], forwards)]
with pytest.raises(ValueError) as exc:
qglue(Data1=self.xy, Data2=self.dict_data, links=links)
assert exc.value.args[0] == "Invalid link (no component named Data1.a)"
def test_bad_data_shape(self):
with pytest.raises(ValueError) as exc:
qglue(d=self.bad_data)
assert exc.value.args[0].startswith("Invalid format for data 'd'")
def test_bad_data_format(self):
with pytest.raises(TypeError) as exc:
qglue(d=5)
assert exc.value.args[0].startswith("Invalid data description")
def test_malformed_data_dict(self):
with pytest.raises(ValueError) as exc:
qglue(d={'x': 'bad'})
assert exc.value.args[0].startswith("Invalid format for data 'd'")
glueviz-1.0.1+dfsg.orig/glue/tests/example_data.py 0000644 0001750 0001750 00000003277 13605357235 021522 0 ustar noahfx noahfx import numpy as np
from glue.core.component import Component, CategoricalComponent
from glue.core.data import Data
def test_histogram_data():
data = Data(label="Test Data")
comp_a = Component(np.random.uniform(size=500))
comp_b = Component(np.random.normal(size=500))
data.add_component(comp_a, 'uniform')
data.add_component(comp_b, 'normal')
return data
def test_data():
data = Data(label="Test Data 1")
data2 = Data(label="Teset Data 2")
comp_a = Component(np.array([1, 2, 3]))
comp_b = Component(np.array([1, 2, 3]))
comp_c = Component(np.array([2, 4, 6]))
comp_d = Component(np.array([1, 3, 5]))
data.add_component(comp_a, 'a')
data.add_component(comp_b, 'b')
data2.add_component(comp_c, 'c')
data2.add_component(comp_d, 'd')
return data, data2
def test_categorical_data():
data = Data(label="Test Cat Data 1")
data2 = Data(label="Teset Cat Data 2")
comp_x1 = CategoricalComponent(np.array(['a', 'a', 'b']))
comp_y1 = Component(np.array([1, 2, 3]))
comp_x2 = CategoricalComponent(np.array(['c', 'a', 'b']))
comp_y2 = Component(np.array([1, 3, 5]))
data.add_component(comp_x1, 'x1')
data.add_component(comp_y1, 'y1')
data2.add_component(comp_x2, 'x2')
data2.add_component(comp_y2, 'y2')
return data, data2
def test_image():
data = Data(label="Test Image")
comp_a = Component(np.ones((25, 25)))
data.add_component(comp_a, 'test_1')
comp_b = Component(np.zeros((25, 25)))
data.add_component(comp_b, 'test_2')
return data
def test_cube():
data = Data(label="Test Cube")
comp_a = Component(np.ones((16, 16, 16)))
data.add_component(comp_a, 'test_3')
return data
glueviz-1.0.1+dfsg.orig/glue/config.py 0000644 0001750 0001750 00000104504 13661230662 017170 0 ustar noahfx noahfx import os
import imp
import sys
import warnings
from collections import namedtuple
from glue.utils import format_choices
"""
Objects used to configure Glue at runtime.
"""
__all__ = ['Registry', 'SettingRegistry', 'ExporterRegistry',
'ColormapRegistry', 'DataFactoryRegistry', 'QtClientRegistry',
'LinkFunctionRegistry', 'LinkHelperRegistry', 'ViewerToolRegistry',
'LayerActionRegistry', 'ProfileFitterRegistry', 'qt_client', 'data_factory',
'link_function', 'link_helper', 'colormaps', 'exporters', 'settings',
'fit_plugin', 'auto_refresh', 'importer', 'DictRegistry',
'preference_panes', 'PreferencePanesRegistry',
'DataExporterRegistry', 'data_exporter', 'layer_action',
'SubsetMaskExporterRegistry', 'SubsetMaskImporterRegistry',
'StartupActionRegistry', 'startup_action', 'QtFixedLayoutTabRegistry',
'qt_fixed_layout_tab', 'KeyboardShortcut', 'keyboard_shortcut',
'LayerArtistMakerRegistry', 'layer_artist_maker',
'SessionPatchRegistry', 'session_patch',
'AutoLinkerRegistry', 'autolinker',
'DataTranslatorRegistry', 'data_translator',
'SubsetDefinitionTranslatorRegistry', 'subset_state_translator']
CFG_DIR = os.path.join(os.path.expanduser('~'), '.glue')
class Registry(object):
"""Container to hold groups of objects or settings.
Registry instances are used by Glue to track objects
used for various tasks like data linking, widget creation, etc.
They have the following properties:
- A `members` property, which lists each item in the registry
- A `default_members` function, which can be overridden to lazily
initialize the members list
- A call interface, allowing the instance to be used as a decorator
for users to add new items to the registry in their config files
"""
def __init__(self):
self._members = []
self._lazy_members = []
self._loaded = False
@property
def members(self):
""" A list of the members in the registry.
The return value is a list. The contents of the list
are specified in each subclass"""
self._load_lazy_members()
if not self._loaded:
self._members = self.default_members() + self._members
self._loaded = True
return self._members
def default_members(self):
"""The member items provided by default. These are put in this
method so that code is only imported when needed"""
return []
def add(self, value):
"""
Add a new item to the registry.
"""
self._members.append(value)
def lazy_add(self, value):
"""
Add a reference to a plugin which will be loaded when needed.
"""
self._lazy_members.append(value)
def _load_lazy_members(self):
from glue.plugins import load_plugin
while self._lazy_members:
plugin = self._lazy_members.pop()
load_plugin(plugin)
def __iter__(self):
return iter(self.members)
def __len__(self):
return len(self.members)
def __contains__(self, value):
return value in self.members
def __call__(self, arg):
"""This is provided so that registry instances can be used
as decorators. The decorators should add the decorated
code object to the registry, and return the original function"""
self.add(arg)
return arg
class DictRegistry(Registry):
"""
Base class for registries that are based on dictionaries instead of lists
of objects.
"""
def __init__(self):
self._members = {}
self._lazy_members = []
self._loaded = False
@property
def members(self):
self._load_lazy_members()
if not self._loaded:
defaults = self.default_members()
for key in defaults:
if key in self._members:
self._members[key].extend(defaults[key])
else:
self._members[key] = defaults[key]
self._loaded = True
return self._members
def default_members(self):
return {}
class SettingRegistry(DictRegistry):
"""Stores key/value settings that code can use to customize Glue
Each member is a tuple of 3 items:
- key: the setting name [str]
- value: the default setting [object]
- validator: A function which tests whether the input is a valid value,
and raises a ValueError if invalid. On valid input,
returns the (possibly sanitized) setting value.
"""
def __init__(self):
super(SettingRegistry, self).__init__()
self._validators = {}
self._defaults = {}
def add(self, key, default=None, validator=None):
if validator is None:
validator = lambda x: x
self._defaults[key] = validator(default)
self._validators[key] = validator
def __getattr__(self, attr):
if attr.startswith('_'):
raise AttributeError("No such setting: {0}".format(attr))
else:
if attr in self._members:
return self._members[attr]
elif attr in self._defaults:
return self._defaults[attr]
else:
raise AttributeError("No such setting: {0}".format(attr))
def __setattr__(self, attr, value):
if attr.startswith('_'):
object.__setattr__(self, attr, value)
elif attr in self:
self._members[attr] = self._validators[attr](value)
else:
raise AttributeError("No such setting: {0}".format(attr))
def __dir__(self):
return sorted(self._members.keys())
def __contains__(self, setting):
return setting in self._defaults
def __iter__(self):
for key in self._defaults:
value = self._members.get(key, self._defaults[key])
yield key, value, self._validators[key]
def __str__(self):
s = ""
for name, value, validator in self:
s += "{0}: {1}\n".format(name, value)
return s
def reset_defaults(self):
self._members.clear()
def is_default(self, setting):
return setting in self._defaults and setting not in self._members
class QGlueParserRegistry(Registry):
"""
Registry for parsers that can be used to interpret arguments to the
:func:`~glue.qglue` function.
The members property is a list of parsers, each represented as a named tuple
with ``data_class``, ``parser`` and ``priority`` attributes, where ``class``
defines the class for which to use the parser, and ``parser`` is a function
that takes the input data and returns a list of glue
:class:`~glue.core.data.Data` objects. The ``parser`` functions should take two
arguments: the variable containing the data being parsed, and a label. In
addition, the priority (defaulting to 0) can be specified in case one wants
to make sure sub-classes get tested before more general classes. The
priority should be a numerical value, and the larger it is the higher the
priority.
"""
item = namedtuple('DataFactory', 'data_class parser priority')
def add(self, data_class, parser, priority=0):
"""
Add a new parser
Parameters
----------
data_class : class
The type of of data for which to use the specified parser
parser : func
The function to use to parse the input data
priority : int, optional
The priority, which is used to determine the order in which to check
the parsers.
"""
self.members.append(self.item(data_class, parser, priority))
def __call__(self, data_class, priority=0):
def adder(func):
if isinstance(data_class, tuple):
for dc in data_class:
self.add(dc, func, priority=priority)
else:
self.add(data_class, func, priority=priority)
return func
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: -x.priority):
yield member
class DataImportRegistry(Registry):
"""
Stores functions which can import data.
The members property is a list of importers, each represented as a
``(label, load_function)`` tuple. The ``load_function`` should take no
arguments and return a list of :class:`~glue.core.data.Data` objects.
"""
def add(self, label, importer):
"""
Add a new importer
:param label: Short label for the importer
:type label: str
:param importer: importer function
:type importer: function()
"""
self.members.append((label, importer))
def __call__(self, label):
def adder(func):
self.add(label, func)
return func
return adder
class MenubarPluginRegistry(Registry):
"""
Stores menubar plugins.
The members property is a list of menubar plugins, each represented as a
``(label, function)`` tuple. The ``function`` should take two items which
are a reference to the session and to the data collection respectively.
"""
def add(self, label, function):
"""
Add a new menubar plugin
:param label: Short label for the plugin
:type label: str
:param function: function
:type function: function()
"""
self.members.append((label, function))
def __call__(self, label):
def adder(func):
self.add(label, func)
return func
return adder
class PreferencePanesRegistry(DictRegistry):
"""
Stores preference panes
The members property is a list of tuples of Qt widget classes that can have
their own tab in the preferences window.
"""
def add(self, label, widget_cls):
self._members[label] = widget_cls
def __iter__(self):
for label in self._members:
yield label, self._members[label]
class AutoLinkerRegistry(Registry):
"""
Registry for auto-linking functions that given a data collection can suggest
links.
The members property is a list of auto-linking plugins, each represented as
a ``(label, function)`` tuple. The ``function`` should take a reference to
the data collection.
"""
def add(self, label, function):
"""
Add a new auto-linking function.
Parameters
----------
label : str
Short label for the plugin
function : func
The plugin function
"""
self.members.append((label, function))
def __call__(self, label):
def adder(func):
self.add(label, func)
return func
return adder
class ExporterRegistry(Registry):
"""Stores functions which can export an application to an output file
The members property is a list of exporters, each represented
as a (label, save_function, can_save_function, outmode) tuple.
save_function takes an (application, path) as input, and saves
the session
can_save_function takes an application as input, and raises an
exception if saving this session is not possible
outmode is a string, with one of 3 values:
'file': indicates that exporter creates a file
'directory': exporter creates a directory
'label': exporter doesn't write to disk, but needs a label
"""
def add(self, label, exporter, checker, outmode=None):
"""
Add a new exporter
Parameters
----------
label : str
Short label for the exporter
exporter : func
Exporter function which takes two arguments: the application and
optionally the path or label to create. This function should raise
an exception if export isn't possible.
checker : func
Function that checks if saving is possible, which takes one
argument: the application.
outmode : str or `None`
Indicates what kind of output is created. This can be either set to
``'file'``, ``'directory'``, ``'label'``, or `None`.
"""
self.members.append((label, exporter, checker, outmode))
class ColormapRegistry(Registry):
"""Stores colormaps for the Image Viewer. The members property is
a list of colormaps, each represented as a [name,cmap] pair.
"""
def default_members(self):
import matplotlib.cm as cm
members = []
members.append(['Gray', cm.gray])
members.append(['Viridis', cm.viridis])
members.append(['Plasma', cm.plasma])
members.append(['Inferno', cm.inferno])
members.append(['Magma', cm.magma])
members.append(['Purple-Blue', cm.PuBu])
members.append(['Yellow-Green-Blue', cm.YlGnBu])
members.append(['Yellow-Orange-Red', cm.YlOrRd])
members.append(['Red-Purple', cm.RdPu])
members.append(['Blue-Green', cm.BuGn])
members.append(['Hot', cm.hot])
members.append(['Red-Blue', cm.RdBu])
members.append(['Red-Yellow-Blue', cm.RdYlBu])
members.append(['Purple-Orange', cm.PuOr])
members.append(['Purple-Green', cm.PRGn])
return members
def add(self, label, cmap):
"""
Add colormap *cmap* with label *label*.
"""
self.members.append([label, cmap])
def __getitem__(self, cmap_name):
for name, cmap in self.members:
if name == cmap_name:
return cmap
raise KeyError(cmap_name)
def name_from_cmap(self, cmap_desired):
for name, cmap in self.members:
if cmap is cmap_desired:
return name
raise ValueError("Could not find name for colormap")
class DataFactoryRegistry(Registry):
"""Stores data factories. Data factories take filenames as input,
and return :class:`~glue.core.data.Data` instances
The members property returns a list of (function, label, identifier,
priority) namedtuples:
- Function is the factory that creates the data object
- label is a short human-readable description of the factory
- identifier is a function that takes ``(filename, **kwargs)`` as input
and returns True if the factory can open the file
- priority is a numerical value that indicates how confident the data
factory is that it should read the data, relative to other data
factories. For example, a highly specialized FITS reader for specific
FITS file types can be given a higher priority than the generic FITS
reader in order to take precedence over it.
New data factories can be registered via::
@data_factory('label_name', identifier=identifier, priority=10)
def new_factory(file_name):
...
If not specified, the priority defaults to 0.
"""
item = namedtuple('DataFactory', 'function label identifier priority deprecated')
def __call__(self, label, identifier=None, priority=None, default='', deprecated=False):
if identifier is None:
identifier = lambda *a, **k: False
if priority is None:
if deprecated:
priority = -1000
else:
priority = 0
def adder(func):
self.add(self.item(func, label, identifier, priority, deprecated))
return func
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: (-x.priority, x.label)):
yield member
class DataExporterRegistry(Registry):
"""
Stores data exporters. Data exporters take a data/subset object as input
followed by a filename.
"""
item = namedtuple('DataFactory', 'function label extension')
def __call__(self, label, extension=[]):
def adder(func):
self.add(self.item(func, label, extension))
return func
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: x.label):
yield member
class SubsetMaskExporterRegistry(DataExporterRegistry):
"""
Stores mask exporters. Mask exporters should take a filename followed by
a dictionary of Numpy boolean arrays all with the same dimensions.
"""
item = namedtuple('SubsetMaskExporter', 'function label extension')
class SubsetMaskImporterRegistry(DataExporterRegistry):
"""
Stores mask importers. Mask importers should take a filename and return a
dictionary of Numpy boolean arrays.
"""
item = namedtuple('SubsetMaskImporter', 'function label extension')
class DataTranslatorRegistry(Registry):
"""
Stores data translators, which are classes that define methods to translate
between :class:`~glue.core.data.Data` objects and other kinds of data
containers.
"""
item = namedtuple('DataTranslator', 'target_cls handler priority')
def __call__(self, target_cls, priority=0):
def adder(handler_cls):
self.add(self.item(target_cls, handler_cls(), priority))
return handler_cls
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: -x.priority):
yield member
def remove(self, target_cls):
for member in self.members[:]:
if member.target_cls is target_cls:
self.members.remove(member)
@property
def supported_classes(self):
return [tr.target_cls for tr in self]
def get_handler_for(self, data_or_class):
for translator in self:
if isinstance(data_or_class, translator.target_cls) or data_or_class is translator.target_cls:
handler = translator.handler
preferred = translator.target_cls
break
else:
if isinstance(data_or_class, type):
raise TypeError("Could not find a class to translate objects of "
"type Data to {0}".format(data_or_class.__name__))
else:
raise TypeError("Could not find a class to translate objects of "
"type {0} to Data".format(data_or_class.__class__.__name__))
return handler, preferred
class SubsetDefinitionTranslatorRegistry(Registry):
"""
Stores subset state translators, which are classes that define methods to
translate between :class:`~glue.core.subset.SubsetState` objects and other
kinds of selection representations.
"""
item = namedtuple('SubsetDefinitionTranslator', 'format handler priority')
def __call__(self, format, priority=0):
def adder(handler_cls):
self.add(self.item(format, handler_cls(), priority))
return handler_cls
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: -x.priority):
yield member
def remove(self, format):
for member in self.members[:]:
if member.format is format:
self.members.remove(member)
@property
def supported_classes(self):
return [tr.target_cls for tr in self]
def get_handler_for(self, format):
for translator in self:
if translator.format == format:
return translator.handler
all_formats = [translator.format for translator in self]
if format is None:
raise ValueError("Subset state handler format not set - should be one of:" + format_choices(all_formats))
else:
raise ValueError("Invalid subset state handler format '{0}' - should be one of:".format(format) + format_choices(all_formats))
class QtClientRegistry(Registry):
"""
Stores QT widgets to visualize data.
The members property is a list of Qt widget classes
New widgets can be registered via::
@qt_client
class CustomWidget(QMainWindow):
...
"""
class QtFixedLayoutTabRegistry(Registry):
"""
Stores Qt pre-defined tabs (non-MDI)
New widgets can be registered via::
@qt_fixed_layout_tab
class CustomTab(QWidget):
...
"""
class ViewerToolRegistry(DictRegistry):
def add(self, tool_cls):
"""
Add a tool class to the registry. The the ``tool_id`` attribute on the
tool_cls should be set, and is used by the viewers to indicate which
tools they want to
"""
if tool_cls.tool_id in self.members:
raise ValueError("Tool ID '{0}' already registered".format(tool_cls.tool_id))
else:
self.members[tool_cls.tool_id] = tool_cls
def __call__(self, tool_cls):
self.add(tool_cls)
return tool_cls
class StartupActionRegistry(DictRegistry):
def add(self, startup_name, startup_function):
"""
Add a startup function to the registry. This is a function that will
get called once glue has been started and any data loaded, and can
be used to set up specific layouts and create links.
Startup actions are triggered by either specifying comma-separated names
of actions on the command-line::
glue --startup=mystartupaction
or by passing an iterable of startup action names to the ``startup``
keyword of ``GlueApplication``.
The startup function will be given the session object and the data
collection object.
"""
if startup_name in self.members:
raise ValueError("A startup action with the name '{0}' already exists".format(startup_name))
else:
self.members[startup_name] = startup_function
def __call__(self, name):
def adder(func):
self.add(name, func)
return func
return adder
class LinkFunctionRegistry(Registry):
"""Stores functions to convert between quantities
The members property is a list of (function, info_string,
output_labels) namedtuples. ``info_string`` describes what the
function does. ``output_labels`` is a list of names for each output.
``category`` is a category in which the link function will appear (defaults
to 'General').
New link functions can be registered via
@link_function(info="maps degrees to arcseconds",
output_labels=['arcsec'])
def degrees2arcsec(degrees):
return degrees * 3600
Link functions are expected to receive and return numpy arrays
"""
item = namedtuple('LinkFunction', 'function info output_labels category')
def __call__(self, info="", output_labels=None, category='General'):
out = output_labels or []
def adder(func):
self.add(self.item(func, info, out, category))
return func
return adder
class LayerActionRegistry(Registry):
"""
Stores custom menu actions available when the user select one or more
datasets, subset group, or subset in the data collection view.
This members property is a list of named tuples with the following
attributes:
* ``label``: the user-facing name of the action
* ``tooltip``: the text that appears when hovering with the mouse over the action
* ``callback``: the function to call when the action is triggered
* ``icon``: an icon image to use for the layer action
* ``single``: whether to show this action only when selecting single layers (default: `False`)
* ``data``: if ``single`` is `True` whether to only show the action when selecting a dataset
* ``subset_group``: if ``single`` is `True` whether to only show the action when selecting a subset group
* ``subset``: if ``single`` is `True` whether to only show the action when selecting a subset
The callback function is called with two arguments. If ``single`` is
`True`, the first argument is the selected layer, otherwise it is the list
of selected layers. The second argument is the
`~glue.core.data_collection.DataCollection` object.
"""
item = namedtuple('LayerAction', 'label tooltip callback icon single data subset_group, subset')
def __call__(self, label, callback=None, tooltip=None, icon=None, single=False,
data=False, subset_group=False, subset=False):
# Backward-compatibility
if callback is not None:
self.add(self.item(label, tooltip, callback, icon, True,
False, False, True))
return True
def adder(func):
self.add(self.item(label, tooltip, func, icon, single,
data, subset_group, subset))
return func
return adder
class LinkHelperRegistry(Registry):
"""
Stores helper objects that compute many ComponentLinks at once
Link helpers can either be functions or subclasses of
`~glue.core.link_helpers.LinkCollection`. If a function, it should take a
list of `~glue.core.component_id.ComponentIDs` as inputs, and returns an
iterable of `~glue.core.component_link.ComponentLink` objects.
A link helper should only link components between two datasets, and the
order of the inputs to the function should be the
`~glue.core.component_id.ComponentIDs` of the first dataset, followed by
the ones for the second dataset. Human-readable names for the input and
output components should be given using ``input_labels`` and
``output_labels``
New link helpers can be registered with e.g.::
@link_helper('Links degrees and arcseconds in both directions',
input_labels=['degree'], output_labels=['arcsecond'])
def new_helper(degree, arcsecond):
return [ComponentLink([degree], arcsecond, using=lambda d: d*3600),
ComponentLink([arcsecond], degree, using=lambda a: a/3600)]
"""
item = namedtuple('LinkHelper', 'helper category')
def __call__(self, info=None, input_labels=None, output_labels=None, category='General'):
if input_labels is not None and output_labels is None:
warnings.warn('Specifying @link_helper without giving output_labels is '
'deprecated and will be removed in future. See the '
'documentation about how to specify output_labels', UserWarning)
def adder(func):
from glue.core.link_helpers import LinkCollection, functional_link_collection
if not issubclass(func, LinkCollection):
func = functional_link_collection(func, description=info,
labels1=input_labels or [],
labels2=output_labels or [])
self.add(self.item(func, category))
return func
return adder
class ProfileFitterRegistry(Registry):
item = namedtuple('ProfileFitter', 'cls')
def add(self, cls):
"""
Add colormap *cmap* with label *label*.
"""
self.members.append(cls)
def default_members(self):
from glue.core.fitters import __FITTERS__
return list(__FITTERS__)
class BooleanSetting(object):
def __init__(self, default=True):
self.state = default
def __call__(self, state=None):
if state not in [None, True, False]:
raise ValueError("Invalid True/False setting: %s" % state)
if state is not None:
self.state = state
return self.state
class KeyboardShortcut(DictRegistry):
"""
Stores keyboard shortcuts.
The members property is a dictionary within a dictionary of keyboard
shortcuts, which is represented as (viewer,(keybind,function)). The
``function`` should take one item, which is a reference to the session.
"""
def add(self, valid_viewers, keybind, function):
"""
Add a new keyboard shortcut
Parameters
----------
arg1: list
list of viewers where event can be fired
arg2: Qt.Key
type of key event
arg3: function()
function to be run that corresponds with key
"""
if valid_viewers:
for viewer in valid_viewers:
if viewer in self.members:
if keybind in self.members[viewer]:
raise ValueError("Keyboard shortcut '{0}' already registered in {1}".format(keybind, viewer))
else:
self.members[viewer][keybind] = function
else:
self.members[viewer] = {keybind: function}
else:
if None in self.members:
if keybind in self.members[None]:
raise ValueError("Keyboard shortcut '{0}' already registered in {1}".format(keybind, None))
else:
self.members[None][keybind] = function
else:
self.members[None] = {keybind: function}
def __call__(self, keybind, valid_viewers):
def adder(func):
self.add(valid_viewers, keybind, func)
return func
return adder
class LayerArtistMakerRegistry(Registry):
"""
A registry that allows customization of layer artists based on the data
and viewer type.
"""
item = namedtuple('LayerArtistMaker', 'label function priority')
def add(self, label, function, priority=0):
"""
Add a new plugin for providing custom layer artists.
Plugins take the form of functions that take two arguments - the data or
subset being added, and the viewer. The function should either return a
`~glue.viewers.common.layer_artist.LayerArtist` sub-class object or
`None`.
Parameters
----------
label : str
Name for the plugin
function : callable
The function that returns layer artists
priority : int, optional
Set this to a higher number if multiple plugins are present
and you want your plugin to take precedence over another.
"""
self.members.append(self.item(label, function, priority))
def __call__(self, label, priority=0):
def adder(func):
self.add(label, func, priority=priority)
return func
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: -x.priority):
yield member
class SessionPatchRegistry(Registry):
"""A registry that allows in-place patch of the session file"""
item = namedtuple('SessionPatch', 'function priority')
def add(self, function, priority=0):
"""
Add a new plugin for providing custom in-place session patch.
Plugins take the form of functions that take one argument: the session
object (a dictionary). It should returns `None`.
Parameters
----------
function : callable
The function apply the patch *in-place*
priority : int, optional
Set this to a higher number if multiple plugins are present
and you want your plugin to take precedence over another.
"""
self.members.append(self.item(function, priority))
def __call__(self, priority=0):
def adder(func):
self.add(func, priority=priority)
return func
return adder
def __iter__(self):
for member in sorted(self.members, key=lambda x: -x.priority):
yield member
layer_artist_maker = LayerArtistMakerRegistry()
qt_client = QtClientRegistry()
qt_fixed_layout_tab = QtFixedLayoutTabRegistry()
viewer_tool = ViewerToolRegistry()
link_function = LinkFunctionRegistry()
link_helper = LinkHelperRegistry()
colormaps = ColormapRegistry()
importer = DataImportRegistry()
exporters = ExporterRegistry()
settings = SettingRegistry()
fit_plugin = ProfileFitterRegistry()
layer_action = LayerActionRegistry()
menubar_plugin = MenubarPluginRegistry()
preference_panes = PreferencePanesRegistry()
qglue_parser = QGlueParserRegistry()
startup_action = StartupActionRegistry()
keyboard_shortcut = KeyboardShortcut()
autolinker = AutoLinkerRegistry()
session_patch = SessionPatchRegistry()
# watch loaded data files for changes?
auto_refresh = BooleanSetting(False)
enable_contracts = BooleanSetting(False)
# Data and subset I/O
data_factory = DataFactoryRegistry()
data_exporter = DataExporterRegistry()
subset_mask_exporter = SubsetMaskExporterRegistry()
subset_mask_importer = SubsetMaskImporterRegistry()
data_translator = DataTranslatorRegistry()
subset_state_translator = SubsetDefinitionTranslatorRegistry()
# Backward-compatibility
single_subset_action = layer_action
def load_configuration(search_path=None):
"""
Find and import a config.py file
Returns:
The module object
Raises:
Exception, if no module was found
"""
search_order = search_path or _default_search_order()
result = imp.new_module('config')
for config_file in search_order:
dir = os.path.dirname(config_file)
try:
sys.path.append(dir)
config = imp.load_source('config', config_file)
result = config
except IOError:
pass
except Exception as e:
raise type(e)("Error loading config file %s:\n%s" % (config_file, e), sys.exc_info()[2])
finally:
sys.path.remove(dir)
return result
def _default_search_order():
"""
The default configuration file search order:
* current working directory
* environ var GLUERC
* HOME/.glue/config.py
* Glue's own default config
"""
search_order = [os.path.join(os.getcwd(), 'config.py')]
if 'GLUERC' in os.environ:
search_order.append(os.environ['GLUERC'])
search_order.append(os.path.join(CFG_DIR, 'config.py'))
return search_order[::-1]
# ##### Now define global settings ######
GRAY = '#7F7F7F'
BLUE = "#1F78B4"
GREEN = "#33A02C"
RED = "#E31A1C"
ORANGE = "#FF7F00"
PURPLE = "#6A3D9A"
YELLOW = "#FFFF99"
BROWN = "#8C510A"
PINK = "#FB9A99"
LIGHT_BLUE = "#A6CEE3"
LIGHT_GREEN = "#B2DF8A"
LIGHT_RED = "#FB9A99"
LIGHT_ORANGE = "#FDBF6F"
LIGHT_PURPLE = "#CAB2D6"
settings.add('SUBSET_COLORS', [RED, GREEN, BLUE, BROWN, ORANGE, PURPLE, PINK], validator=list)
settings.add('DATA_COLOR', '#595959')
settings.add('DATA_ALPHA', 0.8, validator=float)
settings.add('BACKGROUND_COLOR', '#FFFFFF')
settings.add('FOREGROUND_COLOR', '#000000')
settings.add('SHOW_LARGE_DATA_WARNING', True, validator=bool)
settings.add('SHOW_INFO_PROFILE_OPEN', True, validator=bool)
settings.add('SHOW_WARN_PROFILE_DUPLICATE', True, validator=bool)
settings.add('FONT_SIZE', -1.0, validator=float)
settings.add('AUTOLINK', {}, validator=dict)
glueviz-1.0.1+dfsg.orig/glue/conftest.py 0000644 0001750 0001750 00000006645 13752534424 017563 0 ustar noahfx noahfx import os
import sys
import warnings
import pytest
try:
from qtpy import PYSIDE2
except Exception:
PYSIDE2 = False
from glue.config import CFG_DIR as CFG_DIR_ORIG
try:
import objgraph
except ImportError:
OBJGRAPH_INSTALLED = False
else:
OBJGRAPH_INSTALLED = True
STDERR_ORIGINAL = sys.stderr
ON_APPVEYOR = os.environ.get('APPVEYOR', 'False') == 'True'
def pytest_runtest_teardown(item, nextitem):
sys.stderr = STDERR_ORIGINAL
global start_dir
os.chdir(start_dir)
def pytest_addoption(parser):
parser.addoption("--no-optional-skip", action="store_true", default=False,
help="don't skip any tests with optional dependencies")
start_dir = None
def pytest_configure(config):
global start_dir
start_dir = os.path.abspath('.')
os.environ['GLUE_TESTING'] = 'True'
if config.getoption('no_optional_skip'):
from glue.tests import helpers
for attr in helpers.__dict__:
if attr.startswith('requires_'):
# The following line replaces the decorators with a function
# that does noting, effectively disabling it.
setattr(helpers, attr, lambda f: f)
# Make sure we don't affect the real glue config dir
import tempfile
from glue import config
config.CFG_DIR = tempfile.mkdtemp()
# Start up QApplication, if the Qt code is present
try:
from glue.utils.qt import get_qapp
except Exception:
# Note that we catch any exception, not just ImportError, because
# QtPy can raise a PythonQtError.
pass
else:
get_qapp()
# Force loading of plugins
from glue.main import load_plugins
load_plugins()
def pytest_report_header(config):
from glue import __version__
glue_version = "%20s:\t%s" % ("glue", __version__)
from glue._deps import get_status
return os.linesep + glue_version + os.linesep + os.linesep + get_status()
def pytest_unconfigure(config):
os.environ.pop('GLUE_TESTING')
# Reset configuration directory to original one
from glue import config
config.CFG_DIR = CFG_DIR_ORIG
# Remove reference to QApplication to prevent segmentation fault on PySide
try:
from glue.utils.qt import app
app.qapp = None
except Exception: # for when we run the tests without the qt directories
# Note that we catch any exception, not just ImportError, because
# QtPy can raise a PythonQtError.
pass
if OBJGRAPH_INSTALLED and not ON_APPVEYOR:
# Make sure there are no lingering references to GlueApplication
obj = objgraph.by_type('GlueApplication')
if len(obj) > 0:
objgraph.show_backrefs(objgraph.by_type('GlueApplication'))
warnings.warn('There are {0} remaining references to GlueApplication'.format(len(obj)))
# Uncomment when checking for memory leaks
# objgraph.show_most_common_types(limit=100)
# With PySide2, tests can fail in a non-deterministic way with the following
# error:
#
# AttributeError: 'PySide2.QtGui.QStandardItem' object has no attribute 'connect'
#
# Until this can be properly debugged and fixed, we xfail any test that fails
# with this exception
if PYSIDE2:
def pytest_runtest_call(__multicall__):
try:
__multicall__.execute()
except AttributeError as exc:
if 'PySide2.QtGui.QStandardItem' in str(exc):
pytest.xfail()
glueviz-1.0.1+dfsg.orig/glue/logger.py 0000644 0001750 0001750 00000000262 13605357235 017202 0 ustar noahfx noahfx from logging import getLogger, basicConfig, NullHandler
basicConfig()
logger = getLogger("glue")
# Default to Null unless we override this later
logger.addHandler(NullHandler())
glueviz-1.0.1+dfsg.orig/glue/viewers/ 0000755 0001750 0001750 00000000000 13752535025 017033 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/ 0000755 0001750 0001750 00000000000 13752535025 021202 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/tests/ 0000755 0001750 0001750 00000000000 13752535025 022344 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/tests/test_mouse_mode.py 0000644 0001750 0001750 00000013451 13605357235 026117 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
from unittest.mock import MagicMock
# from glue.utils.qt import process_dialog
from ..mouse_mode import MouseMode
from ..toolbar_mode import RectangleMode, CircleMode, PolyMode
class Event(object):
def __init__(self, x, y, button=3, key='a'):
self.x = x
self.y = y
self.xdata = x
self.ydata = y
self.button = button
self.key = key
self.inaxes = True
def viewer():
result = MagicMock()
result.axes.figure.canvas.get_width_height.return_value = (640, 480)
return result
class TestMouseMode(object):
def setup_method(self, method):
self.mode = self.mode_factory()(viewer())
self.axes = self.mode._axes
self.attach_callbacks()
def attach_callbacks(self):
self.press = self.mode._press_callback = MagicMock()
self.move = self.mode._move_callback = MagicMock()
self.release = self.mode._release_callback = MagicMock()
def mode_factory(self):
return MouseMode
def test_press_callback(self):
e = Event(1, 2)
self.mode.press(e)
self.press.assert_called_once_with(self.mode)
assert self.move.call_count == 0
assert self.release.call_count == 0
# def test_log_null_event(self):
# """ Should exit quietly if event is None """
# self.mode._log_position(None)
def test_move_callback(self):
e = Event(1, 2)
self.mode.move(e)
self.move.assert_called_once_with(self.mode)
assert self.press.call_count == 0
assert self.release.call_count == 0
def test_release_callback(self):
e = Event(1, 2)
self.mode.release(e)
self.release.assert_called_once_with(self.mode)
assert self.press.call_count == 0
assert self.move.call_count == 0
def test_press_log(self):
e = Event(1, 2)
self.mode.press(e)
assert self.mode._event_x == 1
assert self.mode._event_y == 2
def test_move_log(self):
e = Event(1, 2)
self.mode.move(e)
assert self.mode._event_x == 1
assert self.mode._event_y == 2
def test_release_log(self):
e = Event(1, 2)
self.mode.release(e)
assert self.mode._event_x == 1
assert self.mode._event_y == 2
class TestRoiMode(TestMouseMode):
def setup_method(self, method):
TestMouseMode.setup_method(self, method)
self.mode._roi_tool = MagicMock()
def mode_factory(self):
raise NotImplementedError()
def test_roi_not_called_on_press(self):
e = Event(1, 2)
self.mode.press(e)
assert self.mode._roi_tool.start_selection.call_count == 0
def test_roi_called_on_drag(self):
e = Event(1, 2)
e2 = Event(10, 200)
self.mode.press(e)
self.mode.move(e2)
self.mode._roi_tool.start_selection.assert_called_once_with(e)
self.mode._roi_tool.update_selection.assert_called_once_with(e2)
# def test_roi_ignores_small_drags(self):
# e = Event(1, 2)
# e2 = Event(1, 3)
# self.mode.press(e)
# self.mode.move(e2)
# assert self.mode._roi_tool.start_selection.call_count == 0
# assert self.mode._roi_tool.update_selection.call_count == 0
def test_roi_called_on_release(self):
e = Event(1, 2)
e2 = Event(10, 20)
self.mode.press(e)
self.mode.move(e2)
self.mode.release(e2)
self.mode._roi_tool.finalize_selection.assert_called_once_with(e2)
def test_roi(self):
self.mode.roi()
self.mode._roi_tool.roi.assert_called_once_with()
def test_roi_resets_on_escape(self):
e = Event(1, 2)
e2 = Event(1, 30, key='escape')
self.mode.press(e)
self.mode.key(e2)
self.mode.press(e)
assert self.mode._roi_tool.abort_selection.call_count == 1
class TestClickRoiMode(TestMouseMode):
def setup_method(self, method):
TestMouseMode.setup_method(self, method)
self.mode._roi_tool = MagicMock()
self.mode._roi_tool.active.return_value = False
def mode_factory(self):
raise NotImplementedError()
def test_roi_started_on_press(self):
e = Event(1, 2)
self.mode.press(e)
assert self.mode._roi_tool.start_selection.call_count == 1
def test_roi_updates_on_subsequent_presses(self):
e = Event(1, 2)
e2 = Event(1, 30)
self.mode.press(e)
self.mode._roi_tool.active.return_value = True
self.mode.press(e2)
assert self.mode._roi_tool.start_selection.call_count == 1
assert self.mode._roi_tool.update_selection.call_count == 1
def test_roi_finalizes_on_enter(self):
e = Event(1, 2)
e2 = Event(1, 20)
e3 = Event(1, 30, key='enter')
self.mode.press(e)
self.mode._roi_tool.active.return_value = True
self.mode.press(e2)
self.mode.key(e3)
self.mode._roi_tool.start_selection.assert_called_once_with(e)
self.mode._roi_tool.update_selection.assert_called_once_with(e2)
self.mode._roi_tool.finalize_selection.assert_called_once_with(e2)
def test_roi_resets_on_escape(self):
e = Event(1, 2)
e2 = Event(1, 30, key='escape')
self.mode.press(e)
self.mode.key(e2)
self.mode.press(e)
assert self.mode._roi_tool.abort_selection.call_count == 1
assert self.mode._roi_tool.start_selection.call_count == 2
class TestRectangleMode(TestRoiMode):
def mode_factory(self):
return RectangleMode
class TestCircleMode(TestRoiMode):
def mode_factory(self):
return CircleMode
class TestPolyMode(TestClickRoiMode):
def mode_factory(self):
return PolyMode
del TestRoiMode # prevents test discovery from running abstract test
del TestClickRoiMode
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/tests/test_viewer.py 0000644 0001750 0001750 00000004541 13502206677 025263 0 ustar noahfx noahfx from numpy.testing import assert_allclose
import matplotlib.pyplot as plt
from glue.core.application_base import Application
from glue.viewers.common.viewer import Viewer
from glue.viewers.matplotlib.viewer import MatplotlibViewerMixin
from glue.viewers.matplotlib.state import MatplotlibDataViewerState
def assert_limits(viewer, x_min, x_max, y_min, y_max):
# Convenience to check both state and matplotlib
assert_allclose(viewer.state.x_min, x_min)
assert_allclose(viewer.state.x_max, x_max)
assert_allclose(viewer.state.y_min, y_min)
assert_allclose(viewer.state.y_max, y_max)
assert_allclose(viewer.axes.get_xlim(), (x_min, x_max))
assert_allclose(viewer.axes.get_ylim(), (y_min, y_max))
def test_aspect_ratio():
# Test of the aspect ratio infrastructure
class CustomViewer(MatplotlibViewerMixin, Viewer):
_state_cls = MatplotlibDataViewerState
def __init__(self, *args, **kwargs):
Viewer.__init__(self, *args, **kwargs)
self.figure = plt.figure(figsize=(12, 6))
self.axes = self.figure.add_axes([0, 0, 1, 1])
MatplotlibViewerMixin.setup_callbacks(self)
def show(self):
pass
class CustomApplication(Application):
def add_widget(self, *args, **kwargs):
pass
app = CustomApplication()
viewer = app.new_data_viewer(CustomViewer)
viewer.state.aspect = 'equal'
assert_limits(viewer, -0.5, 1.5, 0., 1.)
# Test changing x limits in state, which should just change the y limits
viewer.state.x_min = -2.5
assert_limits(viewer, -2.5, 1.5, -0.5, 1.5)
viewer.state.x_max = -1.5
assert_limits(viewer, -2.5, -1.5, 0.25, 0.75)
# Test changing y limits in state, which should just change the x limits
viewer.state.y_max = 1.25
assert_limits(viewer, -3.0, -1.0, 0.25, 1.25)
viewer.state.y_min = 0.75
assert_limits(viewer, -2.5, -1.5, 0.75, 1.25)
# Test changing x limits in Matplotlib, which should just change the x limits
viewer.axes.set_xlim(1., 3.)
assert_limits(viewer, 1.0, 3.0, 0.5, 1.5)
# Test changing x limits in Matplotlib, which should just change the x limits
viewer.axes.set_ylim(0., 2.)
assert_limits(viewer, 0.0, 4.0, 0.0, 2.0)
# We include tests for resizing inside the Qt folder (since this doesn't
# work correctly with the Agg backend)
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/tests/__init__.py 0000644 0001750 0001750 00000000000 13502206677 024444 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/tests/test_state.py 0000755 0001750 0001750 00000001542 13752534424 025104 0 ustar noahfx noahfx from ..state import MatplotlibLegendState
from glue.config import settings
from matplotlib.colors import to_rgba
class TestMatplotlibLegendState:
def setup_method(self, method):
self.state = MatplotlibLegendState()
def test_draggable(self):
self.state.location = 'draggable'
assert self.state.draggable
assert self.state.mpl_location == 'best'
def test_no_draggable(self):
self.state.location = 'lower left'
assert not self.state.draggable
assert self.state.mpl_location == 'lower left'
def test_no_edge(self):
self.state.show_edge = False
assert self.state.edge_color is None
def test_default_color(self):
assert self.state.frame_color == settings.BACKGROUND_COLOR
assert self.state.edge_color == to_rgba(settings.FOREGROUND_COLOR, self.state.alpha)
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/ 0000755 0001750 0001750 00000000000 13752535025 021626 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022770 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/test_toolbar.py 0000644 0001750 0001750 00000005252 13605357235 026051 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.matplotlib.toolbar_mode import ToolbarModeBase
from glue.core.tests.util import simple_session
class ToolbarModeTest(ToolbarModeBase):
tool_id = 'test'
tool_tip = 'just testing'
icon = 'glue_square'
def __init__(self, axes, release_callback=None):
super(ToolbarModeTest, self).__init__(axes, release_callback=release_callback)
self.action_text = 'test text'
self.last_mode = None
def press(self, event):
self.last_mode = 'PRESS'
def move(self, event):
self.last_mode = 'MOVE'
class ExampleViewer(MatplotlibDataViewer):
def __init__(self, session, parent=None):
super(ExampleViewer, self).__init__(session, parent=parent)
self.axes.plot([1, 2, 3])[0]
def initialize_toolbar(self):
super(ExampleViewer, self).initialize_toolbar()
self.tool = ToolbarModeTest(self, release_callback=self.callback)
self.toolbar.add_tool(self.tool)
def callback(self, mode):
self._called_back = True
class TestToolbar(object):
def setup_method(self, method):
self.session = simple_session()
self.viewer = ExampleViewer(self.session)
self._called_back = False
def teardown_method(self, method):
self.viewer.close()
def assert_valid_mode_state(self, target_mode):
for tool_id in self.viewer.toolbar.actions:
if tool_id == target_mode and self.viewer.toolbar.actions[tool_id].isCheckable():
assert self.viewer.toolbar.actions[tool_id].isChecked()
self.viewer.toolbar._active == target_mode
else:
assert not self.viewer.toolbar.actions[tool_id].isChecked()
def test_callback(self):
self.viewer.toolbar.actions['mpl:home'].trigger()
self.viewer.tool.release(None)
assert self.viewer._called_back
def test_change_mode(self):
self.viewer.toolbar.actions['mpl:pan'].toggle()
assert self.viewer.toolbar.active_tool.tool_id == 'mpl:pan'
assert self.viewer._mpl_nav.mode == 'pan/zoom'
self.viewer.toolbar.actions['mpl:pan'].toggle()
assert self.viewer.toolbar.active_tool is None
assert self.viewer._mpl_nav.mode == ''
self.viewer.toolbar.actions['mpl:zoom'].trigger()
assert self.viewer.toolbar.active_tool.tool_id == 'mpl:zoom'
assert self.viewer._mpl_nav.mode == 'zoom rect'
self.viewer.toolbar.actions['test'].trigger()
assert self.viewer.toolbar.active_tool.tool_id == 'test'
assert self.viewer._mpl_nav.mode == ''
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/test_python_export.py 0000644 0001750 0001750 00000002321 13657331477 027332 0 ustar noahfx noahfx import os
import sys
import pytest
import subprocess
import numpy as np
from matplotlib.testing.compare import compare_images
__all__ = ['random_with_nan', 'BaseTestExportPython']
def random_with_nan(nsamples, nan_index):
x = np.random.random(nsamples)
x[nan_index] = np.nan
return x
class BaseTestExportPython:
def assert_same(self, tmpdir, tol=0.1):
os.chdir(tmpdir.strpath)
expected = tmpdir.join('expected.png').strpath
script = tmpdir.join('actual.py').strpath
actual = tmpdir.join('glue_plot.png').strpath
self.viewer.axes.figure.savefig(expected)
self.viewer.export_as_script(script)
subprocess.call([sys.executable, script])
msg = compare_images(expected, actual, tol=tol)
if msg:
from base64 import b64encode
print("SCRIPT:")
with open(script, 'r') as f:
print(f.read())
print("EXPECTED:")
with open(expected, 'rb') as f:
print(b64encode(f.read()).decode())
print("ACTUAL:")
with open(actual, 'rb') as f:
print(b64encode(f.read()).decode())
pytest.fail(msg, pytrace=False)
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/test_toolbar_mode.py 0000644 0001750 0001750 00000002517 13507416115 027050 0 ustar noahfx noahfx from glue.viewers.matplotlib.tests.test_mouse_mode import TestMouseMode, Event
from ..toolbar_mode import ContrastMode
class TestContrastMode(TestMouseMode):
def mode_factory(self):
return ContrastMode
def test_move_ignored_if_not_right_drag(self):
e = Event(1, 2, button=1)
self.mode.move(e)
count = self.mode._axes.figure.canvas.get_width_height.call_count
assert count == 0
def test_clip_percentile(self):
assert self.mode.get_clip_percentile() == (1, 99)
self.mode.set_clip_percentile(2, 33)
assert self.mode.get_clip_percentile() == (2, 33)
def test_vmin_vmax(self):
assert self.mode.get_vmin_vmax() == (None, None)
self.mode.set_vmin_vmax(3, 4)
assert self.mode.get_vmin_vmax() == (3, 4)
assert self.mode.get_clip_percentile() == (None, None)
# TODO: at the moment, this doesn't work because the dialog is non-modal
# assert self.mode.get_vmin_vmax() == (5, 7)
# def test_choose_vmin_vmax(self):
#
# assert self.mode.get_vmin_vmax() == (None, None)
#
# def fill_apply(dialog):
# dialog.vmin.setText('5')
# dialog.vmax.setText('7')
# dialog.accept()
#
# with process_dialog(delay=500, function=fill_apply):
# self.mode.choose_vmin_vmax()
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13502206677 025070 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000054500 13752534424 026701 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import pytest
from numpy.testing import assert_allclose
try:
import objgraph
except ImportError:
OBJGRAPH_INSTALLED = False
else:
OBJGRAPH_INSTALLED = True
from glue.core import Data
from glue.core.exceptions import IncompatibleDataException
from glue.app.qt.application import GlueApplication
from glue.core.roi import XRangeROI
from glue.utils.qt import process_events
from glue.tests.helpers import requires_matplotlib_ge_22
class MatplotlibDrawCounter(object):
def __init__(self, figure):
self.figure = figure
# For recent versions of Matplotlib it seems that we need
# to process events at least twice to really flush out any
# unprocessed events
process_events()
process_events()
self.start = self.figure.canvas._draw_count
@property
def draw_count(self):
process_events()
process_events()
return self.figure.canvas._draw_count - self.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.main_components[0]
self.data_collection.new_subset_group('subset 1', cid > 0)
@property
def viewer_count(self):
process_events()
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:
objgraph.show_backrefs(objgraph.by_type(self.viewer_cls.__name__))
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_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.main_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
viewer_state.x_log = False
viewer_state.y_log = False
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(label=self.data.label)
data.coords = self.data.coords
for cid in self.data.main_components:
if self.data.get_kind(cid) == 'numerical':
data.add_component(self.data[cid] * 2, cid.label)
else:
data.add_component(self.data[cid], cid.label)
self.data.update_values_from_data(data)
assert self.draw_count == 2
@requires_matplotlib_ge_22
def test_aspect_resize(self):
# Make sure that the limits are adjusted appropriately when resizing
# depending on the aspect ratio mode. Note that we don't add any data
# here since it isn't needed for this test.
# This test works with Matplotlib 2.0 and 2.2 but not 2.1, hence we
# skip it with Matplotlib 2.1 above.
# Note that we need to explicitly call draw() below because otherwise
# draw_idle is used, which has no guarantee of being effective.
# Set initial limits to deterministic values
self.viewer.state.aspect = 'auto'
self.viewer.state.x_min = 0.
self.viewer.state.x_max = 1.
self.viewer.state.y_min = 0.
self.viewer.state.y_max = 1.
self.viewer.state.aspect = 'equal'
# Resize events only work if widget is visible
self.viewer.show()
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
def limits(viewer):
return (viewer.state.x_min, viewer.state.x_max,
viewer.state.y_min, viewer.state.y_max)
# Set viewer to an initial size and save limits
self.viewer.viewer_size = (800, 400)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
initial_limits = limits(self.viewer)
# Change the viewer size, and make sure the limits are adjusted
self.viewer.viewer_size = (400, 400)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
with pytest.raises(AssertionError):
assert_allclose(limits(self.viewer), initial_limits)
# Now change the viewer size a number of times and make sure if we
# return to the original size, the limits match the initial ones.
self.viewer.viewer_size = (350, 800)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
self.viewer.viewer_size = (900, 300)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
self.viewer.viewer_size = (600, 600)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
self.viewer.viewer_size = (800, 400)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
assert_allclose(limits(self.viewer), initial_limits)
# Now check that the limits don't change in 'auto' mode
self.viewer.state.aspect = 'auto'
self.viewer.viewer_size = (900, 300)
self.viewer.figure.canvas.draw()
process_events(wait=0.1)
assert_allclose(limits(self.viewer), initial_limits)
def test_update_data_values(self):
# Regression test for a bug that caused some viewers to not behave
# correctly if the data values were updated.
self.viewer.add_data(self.data)
data = self.init_data()
self.data_collection.append(data)
self.data.update_values_from_data(data)
def test_legend(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
# no legend by default
assert self.viewer.axes.get_legend() is None
self.viewer.state.legend.visible = True
# a legend appears
legend = self.viewer.axes.get_legend()
assert not (legend is None)
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 1
assert labels[0] == self.data.label
self.init_subset()
assert len(viewer_state.layers) == 2
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 2
assert labels[1] == 'subset 1'
# The next set of test check that the legend does not create extra draws !
def test_legend_single_draw(self):
# Make sure that the number of draws is kept to a minimum
self.viewer.state.legend.visible = True
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_legend_numerical_data_changed(self):
self.viewer.state.legend.visible = True
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(label=self.data.label)
data.coords = self.data.coords
for cid in self.data.main_components:
if self.data.get_kind(cid) == 'numerical':
data.add_component(self.data[cid] * 2, cid.label)
else:
data.add_component(self.data[cid], cid.label)
self.data.update_values_from_data(data)
assert self.draw_count == 2
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/legend_editor.py 0000755 0001750 0001750 00000000563 13661230662 025011 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from glue.utils.qt import load_ui
__all__ = ['LegendEditorWidget']
class LegendEditorWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(LegendEditorWidget, self).__init__(parent=parent)
self.ui = load_ui('legend_editor.ui', self,
directory=os.path.dirname(__file__))
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/toolbar.py 0000644 0001750 0001750 00000005243 13752534424 023650 0 ustar noahfx noahfx from matplotlib.backends.backend_qt5 import NavigationToolbar2QT
from glue.config import viewer_tool
from glue.viewers.common.tool import CheckableTool, Tool
__all__ = ['MatplotlibTool', 'MatplotlibCheckableTool', 'HomeTool', 'SaveTool',
'PanTool', 'ZoomTool']
def _ensure_mpl_nav(viewer):
# Set up virtual Matplotlib navigation toolbar (don't show it)
if not hasattr(viewer, '_mpl_nav'):
viewer._mpl_nav = NavigationToolbar2QT(viewer.central_widget.canvas, viewer)
viewer._mpl_nav.hide()
def _cleanup_mpl_nav(viewer):
if getattr(viewer, '_mpl_nav', None) is not None:
viewer._mpl_nav.setParent(None)
try:
viewer._mpl_nav.parent = None
except AttributeError:
pass
viewer._mpl_nav = None
class MatplotlibTool(Tool):
def __init__(self, viewer=None):
super(MatplotlibTool, self).__init__(viewer=viewer)
_ensure_mpl_nav(viewer)
def close(self):
_cleanup_mpl_nav(self.viewer)
super(MatplotlibTool, self).close()
class MatplotlibCheckableTool(CheckableTool):
def __init__(self, viewer=None):
super(MatplotlibCheckableTool, self).__init__(viewer=viewer)
_ensure_mpl_nav(viewer)
def close(self):
_cleanup_mpl_nav(self.viewer)
super(MatplotlibCheckableTool, self).close()
@viewer_tool
class HomeTool(MatplotlibTool):
tool_id = 'mpl:home'
icon = 'glue_home'
action_text = 'Home'
tool_tip = 'Reset original zoom'
shortcut = 'H'
def activate(self):
if hasattr(self.viewer, 'state') and hasattr(self.viewer.state, 'reset_limits'):
self.viewer.state.reset_limits()
else:
self.viewer._mpl_nav.home()
@viewer_tool
class SaveTool(MatplotlibTool):
tool_id = 'mpl:save'
icon = 'glue_filesave'
action_text = 'Save plot to file'
tool_tip = 'Save the figure'
def activate(self):
self.viewer._mpl_nav.save_figure()
@viewer_tool
class PanTool(MatplotlibCheckableTool):
tool_id = 'mpl:pan'
icon = 'glue_move'
action_text = 'Pan'
tool_tip = 'Pan axes with left mouse, zoom with right'
shortcut = 'M'
def activate(self):
self.viewer._mpl_nav.pan()
def deactivate(self):
if hasattr(self.viewer, '_mpl_nav'):
self.viewer._mpl_nav.pan()
@viewer_tool
class ZoomTool(MatplotlibCheckableTool):
tool_id = 'mpl:zoom'
icon = 'glue_zoom_to_rect'
action_text = 'Zoom'
tool_tip = 'Zoom to rectangle'
shortcut = 'Z'
def activate(self):
self.viewer._mpl_nav.zoom()
def deactivate(self):
if hasattr(self.viewer, '_mpl_nav'):
self.viewer._mpl_nav.zoom()
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/data_viewer.py 0000644 0001750 0001750 00000005542 13752534424 024502 0 ustar noahfx noahfx from qtpy.QtCore import QTimer
from glue.core.message import ComputationStartedMessage
from glue.viewers.common.qt.data_viewer import DataViewer
from glue.viewers.matplotlib.qt.widget import MplWidget
from glue.viewers.matplotlib.mpl_axes import init_mpl
from glue.utils import defer_draw, decorate_all_methods
from glue.viewers.matplotlib.state import MatplotlibDataViewerState
from glue.viewers.matplotlib.viewer import MatplotlibViewerMixin
# The following import is required to register the viewer tools
from glue.viewers.matplotlib.qt import toolbar # noqa
__all__ = ['MatplotlibDataViewer']
@decorate_all_methods(defer_draw)
class MatplotlibDataViewer(MatplotlibViewerMixin, DataViewer):
_state_cls = MatplotlibDataViewerState
tools = ['mpl:home', 'mpl:pan', 'mpl:zoom']
subtools = {'save': ['mpl:save']}
def __init__(self, session, parent=None, wcs=None, state=None, projection=None):
super(MatplotlibDataViewer, self).__init__(session, parent=parent, state=state)
# Use MplWidget to set up a Matplotlib canvas inside the Qt window
self.mpl_widget = MplWidget()
self.setCentralWidget(self.mpl_widget)
# TODO: shouldn't have to do this
self.central_widget = self.mpl_widget
self.figure, self.axes = init_mpl(self.mpl_widget.canvas.fig, wcs=wcs, projection=projection)
MatplotlibViewerMixin.setup_callbacks(self)
self.central_widget.resize(600, 400)
self.resize(self.central_widget.size())
self._monitor_computation = QTimer()
self._monitor_computation.setInterval(500)
self._monitor_computation.timeout.connect(self._update_computation)
def _update_computation(self, message=None):
# If we get a ComputationStartedMessage and the timer isn't currently
# active, then we start the timer but we then return straight away.
# This is to avoid showing the 'Computing' message straight away in the
# case of reasonably fast operations.
if isinstance(message, ComputationStartedMessage):
if not self._monitor_computation.isActive():
self._monitor_computation.start()
return
for layer_artist in self.layers:
if layer_artist.is_computing:
self.loading_rectangle.set_visible(True)
text = self.loading_text.get_text()
if text.count('.') > 2:
text = 'Computing'
else:
text += '.'
self.loading_text.set_text(text)
self.loading_text.set_visible(True)
self.redraw()
return
self.loading_rectangle.set_visible(False)
self.loading_text.set_visible(False)
self.redraw()
# If we get here, the computation has stopped so we can stop the timer
self._monitor_computation.stop()
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/compute_worker.py 0000644 0001750 0001750 00000003227 13605357235 025253 0 ustar noahfx noahfx import sys
import time
import queue
from glue.utils import queue_to_list
from qtpy.QtCore import Signal, QThread
# For some viewers, we make use of a thread that continuously listens for
# requests to update the profile and we run these as needed. In future,
# we should add the ability to interrupt compute jobs if a newer compute
# job is requested.
class ComputeWorker(QThread):
compute_start = Signal()
compute_end = Signal()
compute_error = Signal(object)
def __init__(self, function):
super(ComputeWorker, self).__init__()
self.function = function
self.running = False
self.work_queue = queue.Queue()
def run(self):
error = None
while True:
time.sleep(1 / 25)
msgs = queue_to_list(self.work_queue)
if 'stop' in msgs:
return
elif len(msgs) == 0:
# We change this here rather than in the try...except below
# to avoid stopping and starting in quick succession.
if self.running:
self.running = False
if error is None:
self.compute_end.emit()
else:
self.compute_error.emit(error)
error = None
continue
# If any resets were requested, honor this
reset = any(msgs)
try:
self.running = True
self.compute_start.emit()
self.function(reset=reset)
except Exception:
error = sys.exc_info()
else:
error = None
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/toolbar_mode.py 0000644 0001750 0001750 00000013566 13605357235 024663 0 ustar noahfx noahfx import os
from qtpy import QtGui, QtWidgets
from glue.utils import nonpartial
from glue.utils.qt import load_ui, cmap2pixmap
from glue.viewers.common.tool import Tool
from glue.config import viewer_tool
from glue.viewers.matplotlib.toolbar_mode import ToolbarModeBase
__all__ = ['ContrastMode', 'ColormapMode']
@viewer_tool
class ContrastMode(ToolbarModeBase):
"""
Uses right mouse button drags to set bias and contrast, DS9-style.
The horizontal position of the mouse sets the bias, the vertical position
sets the contrast.
The move_callback defaults to calling _set_norm on the viewer with the
instance of ConstrastMode as the sole argument.
"""
icon = 'glue_contrast'
tool_id = 'image:contrast'
action_text = 'Contrast'
tool_tip = 'Adjust the bias/contrast'
shortcut = 'B'
def __init__(self, viewer, **kwargs):
super(ContrastMode, self).__init__(viewer, **kwargs)
self.bias = 0.5
self.contrast = 1.0
self._last = None
self._result = None
self._percent_lo = 1.
self._percent_hi = 99.
self.stretch = 'linear'
self._vmin = None
self._vmax = None
def set_clip_percentile(self, lo, hi):
"""Percentiles at which to clip the data at black/white"""
if lo == self._percent_lo and hi == self._percent_hi:
return
self._percent_lo = lo
self._percent_hi = hi
self._vmin = None
self._vmax = None
def get_clip_percentile(self):
if self._vmin is None and self._vmax is None:
return self._percent_lo, self._percent_hi
return None, None
def get_vmin_vmax(self):
if self._percent_lo is None or self._percent_hi is None:
return self._vmin, self._vmax
return None, None
def set_vmin_vmax(self, vmin, vmax):
if vmin == self._vmin and vmax == self._vmax:
return
self._percent_hi = self._percent_lo = None
self._vmin = vmin
self._vmax = vmax
def choose_vmin_vmax(self):
dialog = load_ui('contrastlimits.ui', None,
directory=os.path.dirname(__file__))
v = QtGui.QDoubleValidator()
dialog.vmin.setValidator(v)
dialog.vmax.setValidator(v)
vmin, vmax = self.get_vmin_vmax()
if vmin is not None:
dialog.vmin.setText(str(vmin))
if vmax is not None:
dialog.vmax.setText(str(vmax))
def _apply():
try:
vmin = float(dialog.vmin.text())
vmax = float(dialog.vmax.text())
self.set_vmin_vmax(vmin, vmax)
if self._move_callback is not None:
self._move_callback(self)
except ValueError:
pass
bb = dialog.buttonBox
bb.button(bb.Apply).clicked.connect(_apply)
dialog.accepted.connect(_apply)
dialog.show()
dialog.raise_()
dialog.exec_()
def move(self, event):
""" MoveEvent. Update bias and contrast on Right Mouse button drag """
if event.button != 3: # RMB drag only
return
x, y = event.x, event.y
dx, dy = self._axes.figure.canvas.get_width_height()
x = 1.0 * x / dx
y = 1.0 * y / dy
self.bias = x
self.contrast = (1 - y) * 10
super(ContrastMode, self).move(event)
def menu_actions(self):
result = []
a = QtWidgets.QAction("minmax", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 0, 100))
result.append(a)
a = QtWidgets.QAction("99%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 1, 99))
result.append(a)
a = QtWidgets.QAction("95%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 5, 95))
result.append(a)
a = QtWidgets.QAction("90%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 10, 90))
result.append(a)
rng = QtWidgets.QAction("Set range...", None)
rng.triggered.connect(nonpartial(self.choose_vmin_vmax))
result.append(rng)
a = QtWidgets.QAction("", None)
a.setSeparator(True)
result.append(a)
a = QtWidgets.QAction("linear", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'linear'))
result.append(a)
a = QtWidgets.QAction("log", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'log'))
result.append(a)
a = QtWidgets.QAction("sqrt", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'sqrt'))
result.append(a)
a = QtWidgets.QAction("asinh", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'arcsinh'))
result.append(a)
for r in result:
if r is rng:
continue
if self._move_callback is not None:
r.triggered.connect(nonpartial(self._move_callback, self))
return result
class ColormapAction(QtWidgets.QAction):
def __init__(self, label, cmap, parent):
super(ColormapAction, self).__init__(label, parent)
self.cmap = cmap
pm = cmap2pixmap(cmap)
self.setIcon(QtGui.QIcon(pm))
@viewer_tool
class ColormapMode(Tool):
"""
A tool to change the colormap used in a viewer.
This calls a ``set_cmap`` method on the viewer, which should take the name
of the colormap as the sole argument.
"""
icon = 'glue_rainbow'
tool_id = 'image:colormap'
action_text = 'Set color scale'
tool_tip = 'Set color scale'
def menu_actions(self):
from glue import config
acts = []
for label, cmap in config.colormaps:
a = ColormapAction(label, cmap, self.viewer)
a.triggered.connect(nonpartial(self.viewer.set_cmap, cmap))
acts.append(a)
return acts
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/__init__.py 0000644 0001750 0001750 00000000043 13507416115 023730 0 ustar noahfx noahfx from . import toolbar_mode # noqa
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/axes_editor.ui 0000644 0001750 0001750 00000012767 13661230662 024506 0 ustar noahfx noahfx
Form
0
0
272
286
Form
5
5
5
5
5
-
y label:
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
70
0
-
-
-
x label:
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
tick label size
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
Qt::Horizontal
-
70
0
-
axis label size
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
axis label weight
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
50
false
x
Qt::AlignCenter
-
-
Qt::Horizontal
40
20
-
Apply to all plots
-
Qt::Horizontal
40
20
-
-
Qt::Vertical
20
0
-
50
false
y
Qt::AlignCenter
-
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/widget.py 0000755 0001750 0001750 00000012241 13605357235 023470 0 ustar noahfx noahfx #!/usr/bin/env python
import warnings
import matplotlib
from matplotlib.figure import Figure
from qtpy import QtCore, QtGui, QtWidgets
from qtpy.QtCore import Qt
from glue.config import settings
from glue.utils.matplotlib import DEFER_DRAW_BACKENDS
from matplotlib.backends.backend_qt5 import FigureManagerQT
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
__all__ = ['MplCanvas', 'MplWidget']
# Register the Qt backend with defer_draw
DEFER_DRAW_BACKENDS.append(FigureCanvasQTAgg)
# We want to ignore warnings about left==right and bottom==top since these are
# not critical and the default behavior makes sense.
warnings.filterwarnings('ignore', '.*Attempting to set identical left==right', UserWarning)
warnings.filterwarnings('ignore', '.*Attempting to set identical bottom==top', UserWarning)
class MplCanvas(FigureCanvasQTAgg):
"""Class to represent the FigureCanvas widget"""
rightDrag = QtCore.Signal(float, float)
leftDrag = QtCore.Signal(float, float)
homeButton = QtCore.Signal()
resize_begin = QtCore.Signal()
resize_end = QtCore.Signal()
def __init__(self):
self._draw_count = 0
interactive = matplotlib.is_interactive()
matplotlib.interactive(False)
self.roi_callback = None
self._draw_zoom_rect = None
self.fig = Figure(facecolor=settings.BACKGROUND_COLOR)
FigureCanvasQTAgg.__init__(self, self.fig)
FigureCanvasQTAgg.setSizePolicy(self,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
FigureCanvasQTAgg.updateGeometry(self)
self.manager = FigureManagerQT(self, 0)
matplotlib.interactive(interactive)
self._resize_timer = QtCore.QTimer()
self._resize_timer.setInterval(250)
self._resize_timer.setSingleShot(True)
self._resize_timer.timeout.connect(self._on_timeout)
self.renderer = None
def _on_timeout(self):
buttons = QtWidgets.QApplication.instance().mouseButtons()
if buttons != Qt.NoButton:
self._resize_timer.start()
else:
self.resize_end.emit()
def paintEvent(self, event):
# super needs this
if self.renderer is None:
self.renderer = self.get_renderer()
super(MplCanvas, self).paintEvent(event)
# See drawRectangle for what _draw_zoom_rect is
if self._draw_zoom_rect is not None:
painter = QtGui.QPainter(self)
self._draw_zoom_rect(painter)
painter.end()
if self.roi_callback is not None:
self.roi_callback(self)
def drawRectangle(self, rect):
# The default zoom rectangle in Matplotlib is quite faint, and there is
# no easy mechanism for changing the default appearance. However, the
# drawing of the zoom rectangle is done in the public method
# drawRectangle on the canvas. This method sets up a callback function
# that is then called during paintEvent. However, we shouldn't use the
# same private attribute since this might break, so we use a private
# attribute with a different name, which means the one matplotlib uses
# will remain empty and not plot anything.
if rect is None:
_draw_zoom_rect = None
else:
def _draw_zoom_rect(painter):
pen = QtGui.QPen(QtGui.QPen(Qt.red, 2, Qt.DotLine))
painter.setPen(pen)
try:
dpi_ratio = self.devicePixelRatio() or 1
except AttributeError: # Matplotlib <2
dpi_ratio = 1
painter.drawRect(*(pt / dpi_ratio for pt in rect))
# This function will be called at the end of the paintEvent
self._draw_zoom_rect = _draw_zoom_rect
# We need to call update to force the canvas to be painted again
self.update()
def resizeEvent(self, event):
if not self._resize_timer.isActive():
self.resize_begin.emit()
self._resize_timer.start()
super(MplCanvas, self).resizeEvent(event)
def draw(self, *args, **kwargs):
self._draw_count += 1
return super(MplCanvas, self).draw(*args, **kwargs)
def keyPressEvent(self, event):
event.setAccepted(False)
super(MplCanvas, self).keyPressEvent(event)
class MplWidget(QtWidgets.QWidget):
"""Widget defined in Qt Designer"""
# signals
rightDrag = QtCore.Signal(float, float)
leftDrag = QtCore.Signal(float, float)
def __init__(self, parent=None):
# initialization of Qt MainWindow widget
QtWidgets.QWidget.__init__(self, parent)
# set the canvas to the Matplotlib widget
self.canvas = MplCanvas()
# create a vertical box layout
self.vbl = QtWidgets.QVBoxLayout()
self.vbl.setContentsMargins(0, 0, 0, 0)
self.vbl.setSpacing(0)
# add mpl widget to the vertical box
self.vbl.addWidget(self.canvas)
# set the layout to the vertical box
self.setLayout(self.vbl)
self.canvas.rightDrag.connect(self.rightDrag)
self.canvas.leftDrag.connect(self.leftDrag)
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/axes_editor.py 0000644 0001750 0001750 00000000553 13605357235 024513 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from glue.utils.qt import load_ui
__all__ = ['AxesEditorWidget']
class AxesEditorWidget(QtWidgets.QWidget):
def __init__(self, parent=None):
super(AxesEditorWidget, self).__init__(parent=parent)
self.ui = load_ui('axes_editor.ui', self,
directory=os.path.dirname(__file__))
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/qt/legend_editor.ui 0000644 0001750 0001750 00000011344 13752534424 024776 0 ustar noahfx noahfx
Form
0
0
272
286
Form
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
Qt::AlignRight|Qt::AlignTop|Qt::AlignTrailing
5
5
5
5
-
0
0
enable
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
location
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
opacity
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
-
0
0
title
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
label size
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
box color
-
0
0
-
-
text color
-
-
box edge
QColorBox
QLabel
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/state.py 0000644 0001750 0001750 00000026033 13752534424 022702 0 ustar noahfx noahfx from echo import CallbackProperty, SelectionCallbackProperty, keep_in_sync, delay_callback
from matplotlib.colors import to_rgba
from glue.core.message import LayerArtistUpdatedMessage
from glue.core.state_objects import State
from glue.viewers.common.state import ViewerState, LayerState
from glue.utils import defer_draw, avoid_circular
__all__ = ['DeferredDrawSelectionCallbackProperty', 'DeferredDrawCallbackProperty',
'MatplotlibDataViewerState', 'MatplotlibLayerState']
class DeferredDrawCallbackProperty(CallbackProperty):
"""
A callback property where drawing is deferred until
after notify has called all callback functions.
"""
@defer_draw
def notify(self, *args, **kwargs):
super(DeferredDrawCallbackProperty, self).notify(*args, **kwargs)
class DeferredDrawSelectionCallbackProperty(SelectionCallbackProperty):
"""
A callback property where drawing is deferred until
after notify has called all callback functions.
"""
@defer_draw
def notify(self, *args, **kwargs):
super(DeferredDrawSelectionCallbackProperty, self).notify(*args, **kwargs)
VALID_WEIGHTS = ['light', 'normal', 'medium', 'semibold', 'bold', 'heavy', 'black']
VALID_LOCATIONS = ['draggable', 'best',
'upper right', 'upper left',
'lower left', 'lower right',
'center left', 'center right',
'lower center', 'upper center']
class MatplotlibLegendState(State):
"""The legend state"""
visible = DeferredDrawCallbackProperty(False, docstring="Whether to show the legend")
location = DeferredDrawSelectionCallbackProperty(0, docstring="The location of the legend in the axis")
title = DeferredDrawCallbackProperty("", docstring='The title of the legend')
fontsize = DeferredDrawCallbackProperty(10, docstring='The font size of the title')
alpha = DeferredDrawCallbackProperty(0.6, docstring='Transparency of the legend frame')
frame_color = DeferredDrawCallbackProperty("#ffffff", docstring='Frame color of the legend')
show_edge = DeferredDrawCallbackProperty(True, docstring="Whether to show the edge of the frame ")
text_color = DeferredDrawCallbackProperty("#000000", docstring='Text color of the legend')
def __init__(self, *args, **kwargs):
MatplotlibLegendState.location.set_choices(self, VALID_LOCATIONS)
super().__init__(*args, **kwargs)
self._set_color_choices()
def _set_color_choices(self):
from glue.config import settings
self.frame_color = settings.BACKGROUND_COLOR
self.text_color = settings.FOREGROUND_COLOR
@property
def edge_color(self):
if self.show_edge:
return to_rgba(self.text_color, self.alpha)
else:
return None
@property
def draggable(self):
return self.location == 'draggable'
@property
def mpl_location(self):
if self.location == 'draggable':
return 'best'
else:
return self.location
def update_axes_settings_from(self, state):
self.visible = state.show_legend
self.loc_and_drag = state.loc_and_drag
self.alpha = state.alpha
self.title = state.title
self.fontsize = state.fontsize
self.frame_color = state.frame_color
self.show_edge = state.show_edge
self.text_color = state.text_color
class MatplotlibDataViewerState(ViewerState):
"""
A base class that includes common attributes for viewers based on
Matplotlib.
"""
x_min = DeferredDrawCallbackProperty(docstring='Lower limit of the visible x range')
x_max = DeferredDrawCallbackProperty(docstring='Upper limit of the visible x range')
y_min = DeferredDrawCallbackProperty(docstring='Lower limit of the visible y range')
y_max = DeferredDrawCallbackProperty(docstring='Upper limit of the visible y range')
x_log = DeferredDrawCallbackProperty(False, docstring='Whether the x axis is logarithmic')
y_log = DeferredDrawCallbackProperty(False, docstring='Whether the y axis is logarithmic')
aspect = DeferredDrawCallbackProperty('auto', docstring='Aspect ratio for the axes')
show_axes = DeferredDrawCallbackProperty(True, docstring='Whether the axes are shown')
x_axislabel = DeferredDrawCallbackProperty('', docstring='Label for the x-axis')
y_axislabel = DeferredDrawCallbackProperty('', docstring='Label for the y-axis')
x_axislabel_size = DeferredDrawCallbackProperty(10, docstring='Size of the x-axis label')
y_axislabel_size = DeferredDrawCallbackProperty(10, docstring='Size of the y-axis label')
x_axislabel_weight = DeferredDrawSelectionCallbackProperty(1, docstring='Weight of the x-axis label')
y_axislabel_weight = DeferredDrawSelectionCallbackProperty(1, docstring='Weight of the y-axis label')
x_ticklabel_size = DeferredDrawCallbackProperty(8, docstring='Size of the x-axis tick labels')
y_ticklabel_size = DeferredDrawCallbackProperty(8, docstring='Size of the y-axis tick labels')
def __init__(self, *args, **kwargs):
self._axes_aspect_ratio = None
MatplotlibDataViewerState.x_axislabel_weight.set_choices(self, VALID_WEIGHTS)
MatplotlibDataViewerState.y_axislabel_weight.set_choices(self, VALID_WEIGHTS)
super(MatplotlibDataViewerState, self).__init__(*args, **kwargs)
self.legend = MatplotlibLegendState(*args, **kwargs)
self.add_callback('aspect', self._adjust_limits_aspect, priority=10000)
self.add_callback('x_min', self._adjust_limits_aspect_x, priority=10000)
self.add_callback('x_max', self._adjust_limits_aspect_x, priority=10000)
self.add_callback('y_min', self._adjust_limits_aspect_y, priority=10000)
self.add_callback('y_max', self._adjust_limits_aspect_y, priority=10000)
def _set_axes_aspect_ratio(self, value):
"""
Set the aspect ratio of the axes in which the visualization is shown.
This is a private method that is intended only for internal use, and it
allows this viewer state class to adjust the limits accordingly when
the aspect callback property is set to 'equal'
"""
self._axes_aspect_ratio = value
self._adjust_limits_aspect(aspect_adjustable='both')
def _adjust_limits_aspect_x(self, *args):
self._adjust_limits_aspect(aspect_adjustable='y')
def _adjust_limits_aspect_y(self, *args):
self._adjust_limits_aspect(aspect_adjustable='x')
@avoid_circular
def _adjust_limits_aspect(self, *args, **kwargs):
"""
Adjust the limits of the visualization to take into account the aspect
ratio. This only works if `_set_axes_aspect_ratio` has been called
previously.
"""
if self.aspect == 'auto' or self._axes_aspect_ratio is None:
return
if self.x_min is None or self.x_max is None or self.y_min is None or self.y_max is None:
return
aspect_adjustable = kwargs.pop('aspect_adjustable', 'auto')
changed = None
# Find axes aspect ratio
axes_ratio = self._axes_aspect_ratio
# Put the limits in temporary variables so that we only actually change
# them in one go at the end.
x_min, x_max = self.x_min, self.x_max
y_min, y_max = self.y_min, self.y_max
# Find current data ratio
data_ratio = abs(y_max - y_min) / abs(x_max - x_min)
# Only do something if the data ratio is sufficiently different
# from the axes ratio.
if abs(data_ratio - axes_ratio) / (0.5 * (data_ratio + axes_ratio)) > 0.01:
# We now adjust the limits - which ones we adjust depends on
# the adjust keyword. We also make sure we preserve the
# mid-point of the current coordinates.
if aspect_adjustable == 'both':
# We need to adjust both at the same time
x_mid = 0.5 * (x_min + x_max)
x_width = abs(x_max - x_min) * (data_ratio / axes_ratio) ** 0.5
y_mid = 0.5 * (y_min + y_max)
y_width = abs(y_max - y_min) / (data_ratio / axes_ratio) ** 0.5
x_min = x_mid - x_width / 2.
x_max = x_mid + x_width / 2.
y_min = y_mid - y_width / 2.
y_max = y_mid + y_width / 2.
elif (aspect_adjustable == 'auto' and data_ratio > axes_ratio) or aspect_adjustable == 'x':
x_mid = 0.5 * (x_min + x_max)
x_width = abs(y_max - y_min) / axes_ratio
x_min = x_mid - x_width / 2.
x_max = x_mid + x_width / 2.
else:
y_mid = 0.5 * (y_min + y_max)
y_width = abs(x_max - x_min) * axes_ratio
y_min = y_mid - y_width / 2.
y_max = y_mid + y_width / 2.
with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'):
self.x_min = x_min
self.x_max = x_max
self.y_min = y_min
self.y_max = y_max
def update_axes_settings_from(self, state):
# axis
self.x_axislabel_size = state.x_axislabel_size
self.y_axislabel_size = state.y_axislabel_size
self.x_axislabel_weight = state.x_axislabel_weight
self.y_axislabel_weight = state.y_axislabel_weight
self.x_ticklabel_size = state.x_ticklabel_size
self.y_ticklabel_size = state.y_ticklabel_size
# legend
self.legend.update_axes_settings_from(state.legend)
@defer_draw
def _notify_global(self, *args, **kwargs):
super(MatplotlibDataViewerState, self)._notify_global(*args, **kwargs)
def _update_priority(self, name):
if name == 'layers':
return 2
elif name.endswith('_log'):
return 0.5
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
class MatplotlibLayerState(LayerState):
"""
A base class that includes common attributes for all layers in viewers based
on Matplotlib.
"""
color = DeferredDrawCallbackProperty(docstring='The color used to display '
'the data')
alpha = DeferredDrawCallbackProperty(docstring='The transparency used to '
'display the data')
def __init__(self, viewer_state=None, **kwargs):
super(MatplotlibLayerState, self).__init__(viewer_state=viewer_state, **kwargs)
self.color = self.layer.style.color
self.alpha = self.layer.style.alpha
self._sync_color = keep_in_sync(self, 'color', self.layer.style, 'color')
self._sync_alpha = keep_in_sync(self, 'alpha', self.layer.style, 'alpha')
self.add_global_callback(self._notify_layer_update)
def _notify_layer_update(self, **kwargs):
message = LayerArtistUpdatedMessage(self)
if self.layer is not None and self.layer.hub is not None:
self.layer.hub.broadcast(message)
@defer_draw
def _notify_global(self, *args, **kwargs):
super(MatplotlibLayerState, self)._notify_global(*args, **kwargs)
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/toolbar_mode.py 0000644 0001750 0001750 00000026110 13752534424 024224 0 ustar noahfx noahfx """
ToolbarModes are CheckableTools that enable various MouseModes.
The toolbar maintains a list of MouseModes from the visualization it is
assigned to, and sees to it that only one MouseMode is active at a time.
Each ToolbarMode appears as an Icon in the toolbar. Classes can assign methods
to the press_callback, move_callback, and release_callback methods of each
Mouse Mode, to implement custom functionality
The basic usage pattern is thus:
* visualization object instantiates the MouseModes it wants
* each of these is passed to the add_tool method of the toolbar
* visualization object optionally attaches methods to the 3 _callback
methods in a MouseMode, for additional behavior
All the mouse modes and tools in this file are Matplotlib-specific.
"""
from glue.core import roi
from glue.viewers.common.tool import CheckableTool
from glue.config import viewer_tool
from .mouse_mode import MouseMode
__all__ = ['ToolbarModeBase', 'RoiModeBase', 'RoiMode', 'PersistentRoiMode',
'ClickRoiMode', 'RectangleMode', 'PathMode', 'CircleMode',
'PolyMode', 'HRangeMode', 'VRangeMode', 'PickMode']
class ToolbarModeBase(MouseMode, CheckableTool):
"""
All ToolbarModes are both MouseModes and CheckableTools
"""
def __init__(self, viewer, **kwargs):
MouseMode.__init__(self, viewer, **kwargs)
CheckableTool.__init__(self, viewer=viewer)
class RoiModeBase(ToolbarModeBase):
"""
Base class for defining ROIs. ROIs accessible via the roi() method
See RoiMode and ClickRoiMode subclasses for interaction details
An roi_callback function can be provided. When ROIs are finalized (i.e.
fully defined), this function will be called with the RoiMode object as the
argument. Clients can use RoiMode.roi() to retrieve the new ROI, and take
the appropriate action. By default, roi_callback will default to calling an
``apply_roi`` method on the data viewer.
"""
persistent = False # clear the shape when drawing completes?
disable_on_finalize = True
def __init__(self, viewer, **kwargs):
"""
Parameters
----------
roi_callback : `func`
Function that will be called when the ROI is finished being
defined.
"""
def apply_mode(mode):
self.viewer.apply_roi(self.roi())
self._roi_callback = kwargs.pop('roi_callback', apply_mode)
super(RoiModeBase, self).__init__(viewer, **kwargs)
self._roi_tool = None
def close(self, *args):
self._roi_callback = None
super(RoiModeBase, self).close()
def activate(self):
# For persistent ROIs, the user might e.g. pan and zoom around before
# the selection is finalized. The Matplotlib ROIs cache the image
# background to make things more efficient, but if the user pans/zooms
# we need to make sure we reset the background.
if getattr(self._roi_tool, '_mid_selection', False):
self._roi_tool._reset_background()
self._roi_tool._sync_patch()
super(RoiModeBase, self).activate()
def roi(self):
"""
The ROI defined by this mouse mode
Returns
-------
roi : :class:`~glue.core.roi.Roi`
"""
return self._roi_tool.roi()
def _finish_roi(self, event):
"""
Called by subclasses when ROI is fully defined
"""
if not self.persistent:
self._roi_tool.finalize_selection(event)
if self._roi_callback is not None:
self._roi_callback(self)
if self.disable_on_finalize:
self.viewer.toolbar.active_tool = None
def clear(self):
self._roi_tool.reset()
class RoiMode(RoiModeBase):
"""
Define Roi Modes via click+drag events.
ROIs are updated continuously on click+drag events, and finalized on each
mouse release
"""
status_tip = "CLICK and DRAG to define selection, CTRL-CLICK and DRAG to move selection"
def __init__(self, viewer, **kwargs):
super(RoiMode, self).__init__(viewer, **kwargs)
self._start_event = None
self._drag = False
def _update_drag(self, event):
if self._drag or self._start_event is None:
return
dx = abs(event.x - self._start_event.x)
dy = abs(event.y - self._start_event.y)
status = self._roi_tool.start_selection(self._start_event)
# If start_selection returns False, the selection has not been
# started and we should abort, so we set self._drag to False in
# this case.
self._drag = True if status is None else status
def press(self, event):
self._start_event = event
super(RoiMode, self).press(event)
def move(self, event):
self._update_drag(event)
if self._drag:
self._roi_tool.update_selection(event)
super(RoiMode, self).move(event)
def release(self, event):
if self._drag:
self._finish_roi(event)
self._drag = False
self._start_event = None
super(RoiMode, self).release(event)
def key(self, event):
if event.key == 'escape':
self._roi_tool.abort_selection(event)
self._drag = False
self._drawing = False
self._start_event = None
super(RoiMode, self).key(event)
class PersistentRoiMode(RoiMode):
"""
Same functionality as RoiMode, but the Roi is never
finalized, and remains rendered after mouse gestures
"""
def _finish_roi(self, event):
if self._roi_callback is not None:
self._roi_callback(self)
class ClickRoiMode(RoiModeBase):
"""
Generate ROIs using clicks and click+drags.
ROIs updated on each click, and each click+drag.
ROIs are finalized on enter press, and reset on escape press.
"""
def __init__(self, viewer, **kwargs):
super(ClickRoiMode, self).__init__(viewer, **kwargs)
self._last_event = None
self._drawing = False
def press(self, event):
if not self._roi_tool.active() or not self._drawing:
self._roi_tool.start_selection(event)
self._drawing = True
else:
self._roi_tool.update_selection(event)
self._last_event = event
super(ClickRoiMode, self).press(event)
def move(self, event):
if event.button is not None and self._roi_tool.active():
self._roi_tool.update_selection(event)
self._last_event = event
super(ClickRoiMode, self).move(event)
def key(self, event):
if event.key == 'enter':
self._finish_roi(self._last_event)
self._drawing = False
elif event.key == 'escape':
self._roi_tool.abort_selection(event)
self._drawing = False
super(ClickRoiMode, self).key(event)
def release(self, event):
if getattr(self._roi_tool, '_scrubbing', False):
self._finish_roi(event)
self._start_event = None
super(ClickRoiMode, self).release(event)
@viewer_tool
class RectangleMode(RoiMode):
"""
Defines a Rectangular ROI, accessible via the :meth:`~RectangleMode.roi`
method
"""
icon = 'glue_square'
tool_id = 'select:rectangle'
action_text = 'Rectangular ROI'
tool_tip = 'Define a rectangular region of interest'
shortcut = 'R'
def __init__(self, viewer, **kwargs):
super(RectangleMode, self).__init__(viewer, **kwargs)
data_space = not hasattr(viewer.state, 'plot_mode') or viewer.state.plot_mode == 'rectilinear'
self._roi_tool = roi.MplRectangularROI(self._axes, data_space=data_space)
class PathMode(ClickRoiMode):
persistent = True
def __init__(self, viewer, **kwargs):
super(PathMode, self).__init__(viewer, **kwargs)
self._roi_tool = roi.MplPathROI(self._axes)
self._roi_tool.plot_opts.update(color='#de2d26',
fill=False,
linewidth=3,
alpha=0.4)
@viewer_tool
class CircleMode(RoiMode):
"""
Defines a Circular ROI, accessible via the :meth:`~CircleMode.roi` method
"""
icon = 'glue_circle'
tool_id = 'select:circle'
action_text = 'Circular ROI'
tool_tip = 'Define a circular region of interest'
shortcut = 'C'
def __init__(self, viewer, **kwargs):
super(CircleMode, self).__init__(viewer, **kwargs)
data_space = not hasattr(viewer.state, 'plot_mode') or viewer.state.plot_mode == 'rectilinear'
self._roi_tool = roi.MplCircularROI(self._axes, data_space=data_space)
@viewer_tool
class PolyMode(ClickRoiMode):
"""
Defines a Polygonal ROI, accessible via the :meth:`~PolyMode.roi` method
"""
icon = 'glue_lasso'
tool_id = 'select:polygon'
action_text = 'Polygonal ROI'
tool_tip = ('Lasso a region of interest\n'
' ENTER accepts the path\n'
' ESCAPE clears the path')
status_tip = ('CLICK and DRAG (or CLICK multiple times) to define selection,'
' ENTER to finalize, ESC to cancel, CTRL-CLICK and DRAG to move selection')
shortcut = 'G'
def __init__(self, viewer, **kwargs):
super(PolyMode, self).__init__(viewer, **kwargs)
data_space = not hasattr(viewer.state, 'plot_mode') or viewer.state.plot_mode == 'rectilinear'
self._roi_tool = roi.MplPolygonalROI(self._axes, data_space=data_space)
@viewer_tool
class HRangeMode(RoiMode):
"""
Defines a Range ROI, accessible via the :meth:`~HRangeMode.roi` method.
This class defines horizontal ranges
"""
icon = 'glue_xrange_select'
tool_id = 'select:xrange'
action_text = 'X range'
tool_tip = 'Select a range of x values'
shortcut = 'X'
def __init__(self, viewer, **kwargs):
super(HRangeMode, self).__init__(viewer, **kwargs)
data_space = not hasattr(viewer.state, 'plot_mode') or viewer.state.plot_mode == 'rectilinear'
self._roi_tool = roi.MplXRangeROI(self._axes, data_space=data_space)
@viewer_tool
class VRangeMode(RoiMode):
"""
Defines a Range ROI, accessible via the :meth:`~VRangeMode.roi` method.
This class defines vertical ranges.
"""
icon = 'glue_yrange_select'
tool_id = 'select:yrange'
action_text = 'Y range'
tool_tip = 'Select a range of y values'
shortcut = 'Y'
def __init__(self, viewer, **kwargs):
super(VRangeMode, self).__init__(viewer, **kwargs)
data_space = not hasattr(viewer.state, 'plot_mode') or viewer.state.plot_mode == 'rectilinear'
self._roi_tool = roi.MplYRangeROI(self._axes, data_space=data_space)
@viewer_tool
class PickMode(RoiMode):
"""
Defines a PointROI.
Defines single point selections.
"""
icon = 'glue_point'
tool_id = 'select:pick'
action_text = 'Click on the item to select'
tool_tip = 'Select a single item'
shortcut = 'K'
def __init__(self, viewer, **kwargs):
super(PickMode, self).__init__(viewer, **kwargs)
self._roi_tool = roi.MplPickROI(self._axes)
def press(self, event):
super(PickMode, self).press(event)
self._drag = True
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/__init__.py 0000644 0001750 0001750 00000000043 13507416115 023304 0 ustar noahfx noahfx from . import toolbar_mode # noqa
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/layer_artist.py 0000644 0001750 0001750 00000005101 13661230662 024251 0 ustar noahfx noahfx import matplotlib.patches as mpatches
from glue.viewers.matplotlib.state import DeferredDrawCallbackProperty
from glue.core.message import ComputationStartedMessage, ComputationEndedMessage
from glue.viewers.common.layer_artist import LayerArtist
__all__ = ['MatplotlibLayerArtist']
class MatplotlibLayerArtist(LayerArtist):
zorder = DeferredDrawCallbackProperty()
visible = DeferredDrawCallbackProperty()
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(MatplotlibLayerArtist, self).__init__(viewer_state,
layer_state=layer_state,
layer=layer)
self.axes = axes
self.mpl_artists = []
def notify_start_computation(self):
"""
Broadcast a message to indicate that this layer artist has started a
computation (typically used in conjunction with asynchronous
operations).
"""
if self.state.layer is not None and self.state.layer.hub is not None:
self.state.layer.hub.broadcast(ComputationStartedMessage(self))
def notify_end_computation(self):
"""
Broadcast a message to indicate that this layer artist has ended a
computation (typically used in conjunction with asynchronous
operations).
"""
if self.state.layer is not None and self.state.layer.hub is not None:
self.state.layer.hub.broadcast(ComputationEndedMessage(self))
def clear(self):
for artist in self.mpl_artists:
try:
artist.set_visible(False)
except AttributeError: # can happen for e.g. errorbars
pass
def remove(self):
for artist in self.mpl_artists:
try:
artist.remove()
except ValueError: # already removed
pass
except TypeError: # can happen for e.g. errorbars
pass
except AttributeError: # can happen for Matplotlib 1.4
pass
self.mpl_artists[:] = []
self._notify_start = None
def get_layer_color(self):
return self.state.color
def get_handle_legend(self):
# The default legend handle for matplotlib viewer
if self.enabled and self.state.visible:
handle = mpatches.Patch(color=self.get_layer_color(), alpha=self.layer.style.alpha)
return handle, self.layer.label, None
else:
return None, None, None
def redraw(self):
self.axes.figure.canvas.draw_idle()
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/mouse_mode.py 0000644 0001750 0001750 00000010546 13630201003 023673 0 ustar noahfx noahfx """
MouseModes define various mouse gestures.
MouseModes are generally activated and deactivated by toolbar buttons, although
not necessarily so. The toolbar maintains a list of MouseModes from the
visualization it is assigned to, and sees to it that only one MouseMode is
active at a time.
Each MouseMode appears as an Icon in the toolbar. Classes can assign methods to
the press_callback, move_callback, and release_callback methods of each Mouse
Mode, to implement custom functionality
The basic usage pattern is thus:
* visualization object instantiates the MouseModes it wants
* each of these is passed to the add_tool method of the toolbar
* visualization object optionally attaches methods to the 3 _callback
methods in a MouseMode, for additional behavior
"""
__all__ = ['MouseMode']
class MouseMode(object):
"""
The base class for all MouseModes.
MouseModes have the following attributes:
* press_callback : Callback method that will be called
whenever a MouseMode processes a mouse press event
* move_callback : Same as above, for move events
* release_callback : Same as above, for release events
* key_callback : Same as above, for release events
The _callback hooks are called with the MouseMode as its only
argument
"""
def __init__(self, viewer,
press_callback=None,
move_callback=None,
release_callback=None,
key_callback=None):
self._axes = getattr(viewer, 'axes', None)
self._canvas = viewer.central_widget.canvas
self._press_callback = press_callback
self._move_callback = move_callback
self._release_callback = release_callback
self._key_callback = key_callback
self._event_x = None
self._event_y = None
self._event_xdata = None
self._event_ydata = None
self._connections = []
def _log_position(self, event):
if event is None:
return
self._event_x, self._event_y = event.x, event.y
self._event_xdata, self._event_ydata = event.xdata, event.ydata
def press(self, event):
"""
Handles mouse presses.
Logs mouse position and calls press_callback method.
Parameters
----------
event : :class:`~matplotlib.backend_bases.MouseEvent`
The event that was triggered
"""
self._log_position(event)
if self._press_callback is not None:
self._press_callback(self)
def move(self, event):
"""
Handles mouse move events.
Logs mouse position and calls move_callback method.
Parameters
----------
event : :class:`~matplotlib.backend_bases.MouseEvent`
The event that was triggered
"""
self._log_position(event)
if self._move_callback is not None:
self._move_callback(self)
def release(self, event):
"""
Handles mouse release events.
Logs mouse position and calls release_callback method.
Parameters
----------
event : :class:`~matplotlib.backend_bases.MouseEvent`
The event that was triggered
"""
self._log_position(event)
if self._release_callback is not None:
self._release_callback(self)
def key(self, event):
"""
Handles key press events.
Calls key_callback method.
Parameters
----------
event : :class:`~matplotlib.backend_bases.KeyEvent`
The event that was triggered
"""
if self._key_callback is not None:
self._key_callback(self)
def activate(self):
"""
Activates all MPL event handlers associated with this mouse mode.
"""
self._connections.append(self._canvas.mpl_connect('button_press_event', self.press))
self._connections.append(self._canvas.mpl_connect('motion_notify_event', self.move))
self._connections.append(self._canvas.mpl_connect('button_release_event', self.release))
self._connections.append(self._canvas.mpl_connect('key_press_event', self.key))
def deactivate(self):
"""
Deactivates all MPL event handlers associated with this mouse mode.
"""
for connection in self._connections:
self._canvas.mpl_disconnect(connection)
self._connections = []
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/mpl_axes.py 0000644 0001750 0001750 00000003676 13752534424 023402 0 ustar noahfx noahfx import matplotlib.pyplot as plt
from glue.utils.matplotlib import freeze_margins
__all__ = ['update_appearance_from_settings', 'init_mpl']
def set_background_color(axes, color):
axes.figure.set_facecolor(color)
axes.patch.set_facecolor(color)
def set_foreground_color(axes, color):
if hasattr(axes, 'coords'):
axes.coords.frame.set_color(color)
axes.coords.frame.set_linewidth(1)
for coord in axes.coords:
coord.set_ticks(color=color)
coord.set_ticklabel(color=color)
coord.axislabels.set_color(color)
else:
for spine in axes.spines.values():
spine.set_color(color)
axes.tick_params(color=color,
labelcolor=color)
axes.xaxis.label.set_color(color)
axes.yaxis.label.set_color(color)
def update_appearance_from_settings(axes):
from glue.config import settings
set_background_color(axes, settings.BACKGROUND_COLOR)
set_foreground_color(axes, settings.FOREGROUND_COLOR)
def init_mpl(figure=None, axes=None, wcs=False, axes_factory=None, projection=None):
if (axes is not None and figure is not None and
axes.figure is not figure):
raise ValueError("Axes and figure are incompatible")
try:
from astropy.visualization.wcsaxes import WCSAxesSubplot
except ImportError:
WCSAxesSubplot = None
if axes is not None:
_axes = axes
_figure = axes.figure
else:
_figure = figure or plt.figure()
if wcs and WCSAxesSubplot is not None:
_axes = WCSAxesSubplot(_figure, 111)
_figure.add_axes(_axes)
else:
if axes_factory is None:
_axes = _figure.add_subplot(1, 1, 1, projection=projection)
else:
_axes = axes_factory(_figure)
freeze_margins(_axes, margins=[1, 0.25, 0.50, 0.25])
update_appearance_from_settings(_axes)
return _figure, _axes
glueviz-1.0.1+dfsg.orig/glue/viewers/matplotlib/viewer.py 0000644 0001750 0001750 00000030712 13752534424 023062 0 ustar noahfx noahfx from textwrap import indent
import numpy as np
from matplotlib.patches import Rectangle
from matplotlib.artist import setp as msetp
from glue.viewers.matplotlib.mpl_axes import update_appearance_from_settings
from echo import delay_callback
from glue.utils import mpl_to_datetime64
__all__ = ['MatplotlibViewerMixin']
SCRIPT_HEADER = """
# Initialize figure
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1, aspect='{aspect}', projection={projection})
# for the legend
legend_handles = []
legend_labels = []
legend_handler_dict = dict()
""".strip()
LIMIT_SCRIPT = """
# Set limits
ax.set_xlim(left={x_min}, right={x_max})
ax.set_ylim(bottom={y_min}, top={y_max})
"""
SCRIPT_FOOTER = """
{limit_script}
{scale_script}
# Set axis label properties
ax.set_xlabel('{x_axislabel}', weight='{x_axislabel_weight}', size={x_axislabel_size})
ax.set_ylabel('{y_axislabel}', weight='{y_axislabel_weight}', size={y_axislabel_size})
# Set tick label properties
ax.tick_params('x', labelsize={x_ticklabel_size})
ax.tick_params('y', labelsize={x_ticklabel_size})
# For manual edition of the plot
# - Uncomment the next code line (plt.show)
# - Also change the matplotlib backend to qt5Agg
# - And comment the "plt.close" line
# plt.show()
# Save figure
fig.savefig('glue_plot.png')
plt.close(fig)
""".strip()
SCRIPT_LEGEND = """
ax.legend(legend_handles, legend_labels,
handler_map=legend_handler_dict,
loc='{location}', # location
framealpha={alpha:.2f}, # opacity of the frame
title='{title}', # title of the legend
title_fontsize={fontsize}, # fontsize of the title
fontsize={fontsize}, # fontsize of the labels
facecolor='{frame_color}',
edgecolor={edge_color}
)
""".strip()
ZORDER_MAX = 100000
class MatplotlibViewerMixin(object):
def setup_callbacks(self):
for spine in self.axes.spines.values():
spine.set_zorder(ZORDER_MAX)
self.loading_rectangle = Rectangle((0, 0), 1, 1, color='0.9', alpha=0.9,
zorder=ZORDER_MAX - 1, transform=self.axes.transAxes)
self.loading_rectangle.set_visible(False)
self.axes.add_patch(self.loading_rectangle)
self.loading_text = self.axes.text(0.4, 0.5, 'Computing', color='k',
zorder=self.loading_rectangle.get_zorder() + 1,
ha='left', va='center',
transform=self.axes.transAxes)
self.loading_text.set_visible(False)
self.state.add_callback('x_min', self.limits_to_mpl)
self.state.add_callback('x_max', self.limits_to_mpl)
self.state.add_callback('y_min', self.limits_to_mpl)
self.state.add_callback('y_max', self.limits_to_mpl)
if (self.state.x_min or self.state.x_max or self.state.y_min or self.state.y_max) is None:
self.limits_from_mpl()
else:
self.limits_to_mpl()
self.state.add_callback('x_log', self.update_x_log, priority=1000)
self.state.add_callback('y_log', self.update_y_log, priority=1000)
self.update_x_log()
self.axes.callbacks.connect('xlim_changed', self.limits_from_mpl)
self.axes.callbacks.connect('ylim_changed', self.limits_from_mpl)
self.figure.canvas.mpl_connect('resize_event', self._on_resize)
self._on_resize()
self.axes.set_autoscale_on(False)
self.state.add_callback('x_axislabel', self.update_x_axislabel)
self.state.add_callback('x_axislabel_weight', self.update_x_axislabel)
self.state.add_callback('x_axislabel_size', self.update_x_axislabel)
self.state.add_callback('y_axislabel', self.update_y_axislabel)
self.state.add_callback('y_axislabel_weight', self.update_y_axislabel)
self.state.add_callback('y_axislabel_size', self.update_y_axislabel)
self.state.add_callback('x_ticklabel_size', self.update_x_ticklabel)
self.state.add_callback('y_ticklabel_size', self.update_y_ticklabel)
self.state.legend.add_callback('visible', self.draw_legend)
self.state.legend.add_callback('location', self.draw_legend)
self.state.legend.add_callback('alpha', self.update_legend)
self.state.legend.add_callback('title', self.draw_legend)
self.state.legend.add_callback('fontsize', self.draw_legend)
self.state.legend.add_callback('frame_color', self.update_legend)
self.state.legend.add_callback('show_edge', self.update_legend)
self.state.legend.add_callback('text_color', self.update_legend)
self.update_x_axislabel()
self.update_y_axislabel()
self.update_x_ticklabel()
self.update_y_ticklabel()
self.draw_legend()
def _update_computation(self, message=None):
pass
def update_x_axislabel(self, *event):
self.axes.set_xlabel(self.state.x_axislabel,
weight=self.state.x_axislabel_weight,
size=self.state.x_axislabel_size)
self.redraw()
def update_y_axislabel(self, *event):
self.axes.set_ylabel(self.state.y_axislabel,
weight=self.state.y_axislabel_weight,
size=self.state.y_axislabel_size)
self.redraw()
def update_x_ticklabel(self, *event):
self.axes.tick_params(axis='x', labelsize=self.state.x_ticklabel_size)
self.axes.xaxis.get_offset_text().set_fontsize(self.state.x_ticklabel_size)
self.redraw()
def update_y_ticklabel(self, *event):
self.axes.tick_params(axis='y', labelsize=self.state.y_ticklabel_size)
self.axes.yaxis.get_offset_text().set_fontsize(self.state.y_ticklabel_size)
self.redraw()
def get_handles_legend(self):
"""Collect the handles and labels from each layer artist."""
handles = []
labels = []
handler_dict = {}
for layer_artist in self._layer_artist_container:
handle, label, handler = layer_artist.get_handle_legend()
if handle is not None:
handles.append(handle)
labels.append(label)
if handler is not None:
handler_dict[handle] = handler
return handles, labels, handler_dict
def _update_legend_visual(self, legend):
"""Update the legend colors and opacity. No redraw."""
msetp(legend.get_title(), color=self.state.legend.text_color)
msetp(legend.get_texts(), color=self.state.legend.text_color)
msetp(legend.get_frame(),
alpha=self.state.legend.alpha,
facecolor=self.state.legend.frame_color,
edgecolor=self.state.legend.edge_color
)
def update_legend(self, *args):
"""Update the legend colors and opacity."""
legend = self.axes.get_legend()
if legend is not None:
self._update_legend_visual(legend)
self.redraw()
def draw_legend(self, *args):
if self.state.legend.visible:
handles, labels, handler_map = self.get_handles_legend()
kwargs = dict(loc=self.state.legend.mpl_location,
title=self.state.legend.title,
title_fontsize=self.state.legend.fontsize,
fontsize=self.state.legend.fontsize)
if handler_map is not None:
kwargs["handler_map"] = handler_map
legend = self.axes.legend(handles, labels, **kwargs)
self._update_legend_visual(legend)
legend.set_draggable(self.state.legend.draggable)
else:
legend = self.axes.get_legend()
if legend is not None:
legend.remove()
self.redraw()
def redraw(self):
self.figure.canvas.draw_idle()
def update_x_log(self, *args):
self.axes.set_xscale('log' if self.state.x_log else 'linear')
self.redraw()
def update_y_log(self, *args):
self.axes.set_yscale('log' if self.state.y_log else 'linear')
self.redraw()
def limits_from_mpl(self, *args, **kwargs):
if getattr(self, '_skip_limits_from_mpl', False):
return
if isinstance(self.state.x_min, np.datetime64):
x_min, x_max = [mpl_to_datetime64(x) for x in self.axes.get_xlim()]
else:
x_min, x_max = self.axes.get_xlim()
if isinstance(self.state.y_min, np.datetime64):
y_min, y_max = [mpl_to_datetime64(y) for y in self.axes.get_ylim()]
else:
y_min, y_max = self.axes.get_ylim()
with delay_callback(self.state, 'x_min', 'x_max', 'y_min', 'y_max'):
self.state.x_min = x_min
self.state.x_max = x_max
self.state.y_min = y_min
self.state.y_max = y_max
def limits_to_mpl(self, *args):
if (self.state.x_min is None or self.state.x_max is None or
self.state.y_min is None or self.state.y_max is None):
return
x_min, x_max = self.state.x_min, self.state.x_max
if self.state.x_log:
if self.state.x_max <= 0:
x_min, x_max = 0.1, 1
elif self.state.x_min <= 0:
x_min = x_max / 10
y_min, y_max = self.state.y_min, self.state.y_max
if self.state.y_log:
if self.state.y_max <= 0:
y_min, y_max = 0.1, 1
elif self.state.y_min <= 0:
y_min = y_max / 10
# Since we deal with aspect ratio internally, there are no conditions
# under which we would want to immediately change the state once the
# limits are set in Matplotlib, so we avoid this by setting the
# _skip_limits_from_mpl attribute which is then recognized inside
# limits_from_mpl
self._skip_limits_from_mpl = True
try:
self.axes.set_xlim(x_min, x_max)
self.axes.set_ylim(y_min, y_max)
self.axes.figure.canvas.draw_idle()
finally:
self._skip_limits_from_mpl = False
@property
def axes_ratio(self):
# Get figure aspect ratio
width, height = self.figure.get_size_inches()
fig_aspect = height / width
# Get axes aspect ratio
l, b, w, h = self.axes.get_position().bounds
axes_ratio = fig_aspect * (h / w)
return axes_ratio
def _on_resize(self, *args):
self.state._set_axes_aspect_ratio(self.axes_ratio)
def _update_appearance_from_settings(self, message=None):
update_appearance_from_settings(self.axes)
self.redraw()
def get_layer_artist(self, cls, layer=None, layer_state=None):
return cls(self.axes, self.state, layer=layer, layer_state=layer_state)
def apply_roi(self, roi, override_mode=None):
""" This method must be implemented by subclasses """
raise NotImplementedError
def _script_header(self):
state_dict = self.state.as_dict()
proj = "'" + self.state.plot_mode + "'" if hasattr(self.state, 'plot_mode') else "None"
state_dict['projection'] = proj
return ['import matplotlib',
"matplotlib.use('Agg')",
"# matplotlib.use('qt5Agg')",
'import matplotlib.pyplot as plt'], SCRIPT_HEADER.format(**state_dict)
def _script_footer(self):
mode = 'rectilinear' if not hasattr(self.state, 'plot_mode') else self.state.plot_mode
state_dict = self.state.as_dict()
temp_str = ''
if mode not in ['aitoff', 'hammer', 'lambert', 'mollweide', 'polar']:
x_log_str = 'log' if self.state.x_log else 'linear'
temp_str += "ax.set_xscale('" + x_log_str + "')\n"
if mode not in ['aitoff', 'hammer', 'lambert', 'mollweide']:
y_log_str = 'log' if self.state.y_log else 'linear'
temp_str += "ax.set_yscale('" + y_log_str + "')\n"
state_dict['scale_script'] = "# Set scale (log or linear)\n" + temp_str if temp_str else ''
full_sphere = ['aitoff', 'hammer', 'lambert', 'mollweide']
state_dict['limit_script'] = '' if mode in full_sphere else LIMIT_SCRIPT.format(**state_dict)
return [], SCRIPT_FOOTER.format(**state_dict)
def _script_legend(self):
state_dict = self.state.legend.as_dict()
state_dict['location'] = self.state.legend.mpl_location
state_dict['edge_color'] = self.state.legend.edge_color
legend_str = SCRIPT_LEGEND.format(**state_dict)
if not self.state.legend.visible:
legend_str = indent(legend_str, "# ")
return [], legend_str
glueviz-1.0.1+dfsg.orig/glue/viewers/table/ 0000755 0001750 0001750 00000000000 13752535025 020122 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/tests/ 0000755 0001750 0001750 00000000000 13752535025 021264 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 023370 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/ 0000755 0001750 0001750 00000000000 13752535025 020546 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 021710 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024014 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000031216 13660522006 025607 0 ustar noahfx noahfx import pytest
import numpy as np
from unittest.mock import MagicMock, patch
from qtpy import QtCore, QtGui
from qtpy.QtCore import Qt
from glue.utils.qt import get_qapp, process_events
from glue.core import Data, DataCollection
from glue.utils.qt import qt_to_mpl_color
from glue.app.qt import GlueApplication
from ..data_viewer import DataTableModel, TableViewer
from glue.core.edit_subset_mode import AndNotMode, OrMode, ReplaceMode
class TestDataTableModel():
def setup_method(self, method):
self.gapp = GlueApplication()
self.viewer = self.gapp.new_data_viewer(TableViewer)
self.data = Data(x=[1, 2, 3, 4], y=[2, 3, 4, 5])
self.gapp.data_collection.append(self.data)
self.viewer.add_data(self.data)
self.model = DataTableModel(self.viewer)
def teardown_method(self, method):
self.gapp.close()
self.gapp = None
def test_column_count(self):
assert self.model.columnCount() == 2
def test_column_count_hidden(self):
self.model.show_coords = True
assert self.model.columnCount() == 3
def test_header_data(self):
for i, c in enumerate(self.data.main_components):
result = self.model.headerData(i, Qt.Horizontal, Qt.DisplayRole)
assert result == c.label
for i in range(self.data.size):
result = self.model.headerData(i, Qt.Vertical, Qt.DisplayRole)
assert result == str(i)
def test_row_count(self):
assert self.model.rowCount() == 4
def test_data(self):
for i, c in enumerate(self.data.main_components):
for j in range(self.data.size):
idx = self.model.index(j, i)
result = self.model.data(idx, Qt.DisplayRole)
assert float(result) == self.data[c, j]
@pytest.mark.xfail
def test_data_2d(self):
self.data = Data(x=[[1, 2], [3, 4]], y=[[2, 3], [4, 5]])
self.model = DataTableModel(self.data)
for i, c in enumerate(self.data.main_components):
for j in range(self.data.size):
idx = self.model.index(j, i)
result = self.model.data(idx, Qt.DisplayRole)
assert float(result) == self.data[c].ravel()[j]
def check_values_and_color(model, data, colors):
for i in range(len(colors)):
for j, colname in enumerate(sorted(data)):
# Get index of cell
idx = model.index(i, j)
# Check values
value = model.data(idx, Qt.DisplayRole)
assert value == str(data[colname][i])
# Check colors
brush = model.data(idx, Qt.BackgroundRole)
if colors[i] is None:
assert brush is None
else:
assert qt_to_mpl_color(brush.color()) == colors[i]
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()
process_events()
# 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)
process_events()
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 test_table_widget_session_no_subset(tmpdir):
# Regression test for a bug that caused table viewers with no subsets to
# not be restored correctly and instead raise an exception.
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)
widget = gapp.new_data_viewer(TableViewer)
widget.add_data(d)
session_file = tmpdir.join('table.glu').strpath
gapp.save_session(session_file)
gapp2 = GlueApplication.restore_session(session_file)
gapp2.show()
gapp2.data_collection[0]
gapp2.viewers[0][0]
def test_change_components():
# Regression test for a bug that caused table viewers to not update when
# adding/removing components.
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_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_add_subset():
# Regression test for a bug that occurred when adding a subset
# directly to the table viewer.
data1 = Data(a=[1, 2, 3, 4, 5], label='test1')
data2 = Data(a=[1, 2, 3, 4, 5], label='test2')
dc = DataCollection([data1, data2])
dc.new_subset_group('test subset 1', data1.id['a'] > 2)
gapp = GlueApplication(dc)
viewer = gapp.new_data_viewer(TableViewer)
viewer.add_subset(data1.subsets[0])
assert len(viewer.state.layers) == 2
assert not viewer.state.layers[0].visible
assert viewer.state.layers[1].visible
dc.new_subset_group('test subset 2', data1.id['a'] <= 2)
assert len(viewer.state.layers) == 3
assert not viewer.state.layers[0].visible
assert viewer.state.layers[1].visible
assert viewer.state.layers[2].visible
viewer.remove_subset(data1.subsets[1])
assert len(viewer.state.layers) == 2
assert not viewer.state.layers[0].visible
assert viewer.state.layers[1].visible
viewer.add_subset(data1.subsets[1])
assert len(viewer.state.layers) == 3
assert not viewer.state.layers[0].visible
assert viewer.state.layers[1].visible
assert viewer.state.layers[2].visible
with pytest.raises(ValueError) as exc:
viewer.add_subset(data2.subsets[1])
assert exc.value.args[0] == 'subset parent data does not match existing table data'
def test_graceful_close_after_invalid(capsys):
# Regression test for a bug that caused an error if an invalid dataset
# was added to the viewer after the user had acknowledged the error.
d = Data(a=[[1, 2], [3, 4]], label='test')
dc = DataCollection([d])
gapp = GlueApplication(dc)
viewer = gapp.new_data_viewer(TableViewer)
gapp.show()
process_events()
with pytest.raises(ValueError, match='Can only use Table widget for 1D data'):
viewer.add_data(d)
viewer.close()
process_events()
# We use capsys here because the # error is otherwise only apparent in stderr.
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
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
glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/data_viewer.py 0000644 0001750 0001750 00000025340 13657331477 023427 0 ustar noahfx noahfx import os
import numpy as np
from qtpy.QtCore import Qt
from qtpy import QtCore, QtGui, QtWidgets
from matplotlib.colors import ColorConverter
from glue.utils.qt import get_qapp
from glue.config import viewer_tool
from glue.core import BaseData, Data
from glue.utils.qt import load_ui
from glue.viewers.common.qt.data_viewer import DataViewer
from glue.viewers.common.qt.toolbar import BasicToolbar
from glue.viewers.common.tool import CheckableTool
from glue.viewers.common.layer_artist import LayerArtist
from glue.core.subset import ElementSubsetState
from glue.utils.colors import alpha_blend_colors
from glue.utils.qt import mpl_to_qt_color, messagebox_on_error
from glue.core.exceptions import IncompatibleAttribute
from glue.viewers.table.compat import update_table_viewer_state
__all__ = ['TableViewer', 'TableLayerArtist']
COLOR_CONVERTER = ColorConverter()
class DataTableModel(QtCore.QAbstractTableModel):
def __init__(self, table_viewer):
super(DataTableModel, self).__init__()
if table_viewer.data.ndim != 1:
raise ValueError("Can only use Table widget for 1D data")
self._table_viewer = table_viewer
self._data = table_viewer.data
self.show_coords = False
self.order = np.arange(self._data.shape[0])
self._update_visible()
def data_changed(self):
top_left = self.index(0, 0)
bottom_right = self.index(self.columnCount(), self.rowCount())
self._update_visible()
self.dataChanged.emit(top_left, bottom_right)
self.layoutChanged.emit()
@property
def columns(self):
if self.show_coords:
return self._data.components
else:
return self._data.main_components + self._data.derived_components
def columnCount(self, index=None):
return len(self.columns)
def rowCount(self, index=None):
# Qt bug: Crashes on tables bigger than this
return min(self.order_visible.size, 71582788)
def headerData(self, section, orientation, role):
if role != Qt.DisplayRole:
return None
if orientation == Qt.Horizontal:
column_name = self.columns[section].label
units = self._data.get_component(self.columns[section]).units
if units != '':
column_name += "\n{0}".format(units)
return column_name
elif orientation == Qt.Vertical:
return str(self.order_visible[section])
def data(self, index, role):
if not index.isValid():
return None
if role == Qt.DisplayRole:
c = self.columns[index.column()]
idx = self.order_visible[index.row()]
comp = self._data[c]
if isinstance(comp[idx], bytes):
return comp[idx].decode('ascii')
else:
return str(comp[idx])
elif role == Qt.BackgroundRole:
idx = self.order_visible[index.row()]
# Find all subsets that this index is part of
colors = []
for layer_artist in self._table_viewer.layers[::-1]:
if isinstance(layer_artist.layer, BaseData):
continue
if layer_artist.visible:
subset = layer_artist.layer
try:
if subset.to_mask(view=slice(idx, idx + 1))[0]:
colors.append(subset.style.color)
except IncompatibleAttribute as exc:
# Only disable the layer if enabled, as otherwise we
# will recursively call clear and _refresh, causing
# an infinite loop and performance issues.
if layer_artist.enabled:
layer_artist.disable_invalid_attributes(*exc.args)
else:
layer_artist.enabled = True
# Blend the colors using alpha blending
if len(colors) > 0:
color = alpha_blend_colors(colors, additional_alpha=0.5)
color = mpl_to_qt_color(color)
return QtGui.QBrush(color)
def sort(self, column, ascending):
c = self.columns[column]
comp = self._data.get_component(c)
self.order = np.argsort(comp.data)
if ascending == Qt.DescendingOrder:
self.order = self.order[::-1]
self._update_visible()
self.layoutChanged.emit()
def _update_visible(self):
"""
Given which layers are visible or not, convert order to order_visible.
"""
# First, if the data layer is visible, show all rows
for layer_artist in self._table_viewer.layers:
if layer_artist.visible and isinstance(layer_artist.layer, BaseData):
self.order_visible = self.order
return
# If not then we need to show only the rows with visible subsets
visible = np.zeros(self.order.shape, dtype=bool)
for layer_artist in self._table_viewer.layers:
if layer_artist.visible:
visible |= layer_artist.layer.to_mask()
self.order_visible = self.order[visible]
class TableLayerArtist(LayerArtist):
def __init__(self, table_viewer, viewer_state, layer_state=None, layer=None):
self._table_viewer = table_viewer
super(TableLayerArtist, self).__init__(viewer_state,
layer_state=layer_state,
layer=layer)
self.redraw()
def _refresh(self):
self._table_viewer.model.data_changed()
def redraw(self):
self._refresh()
def update(self):
self._refresh()
def clear(self):
self._refresh()
@viewer_tool
class RowSelectTool(CheckableTool):
tool_id = 'table:rowselect'
icon = 'glue_row_select'
action_text = 'Select row(s)'
tool_tip = ('Select rows by clicking on rows and pressing enter '
'once the selection is ready to be applied')
status_tip = ('CLICK to select, press ENTER to finalize selection, '
'ALT+CLICK or ALT+UP/DOWN to apply selection immediately')
def __init__(self, viewer):
super(RowSelectTool, self).__init__(viewer)
self.deactivate()
def activate(self):
self.viewer.ui.table.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection)
def deactivate(self):
# Don't do anything if the viewer has already been closed
if self.viewer is None:
return
self.viewer.ui.table.setSelectionMode(QtWidgets.QAbstractItemView.NoSelection)
self.viewer.ui.table.clearSelection()
class TableViewWithSelectionSignal(QtWidgets.QTableView):
selection_changed = QtCore.Signal()
def selectionChanged(self, *args, **kwargs):
self.selection_changed.emit()
super(TableViewWithSelectionSignal, self).selectionChanged(*args, **kwargs)
class TableViewer(DataViewer):
LABEL = "Table Viewer"
_toolbar_cls = BasicToolbar
_data_artist_cls = TableLayerArtist
_subset_artist_cls = TableLayerArtist
inherit_tools = False
tools = ['table:rowselect']
def __init__(self, session, state=None, parent=None, widget=None):
super(TableViewer, self).__init__(session, state=state, parent=parent)
self.ui = load_ui('data_viewer.ui',
directory=os.path.dirname(__file__))
self.setCentralWidget(self.ui)
hdr = self.ui.table.horizontalHeader()
hdr.setStretchLastSection(True)
hdr.setSectionResizeMode(hdr.Interactive)
hdr = self.ui.table.verticalHeader()
hdr.setSectionResizeMode(hdr.Interactive)
self.data = None
self.model = None
self.ui.table.selection_changed.connect(self.selection_changed)
self.state.add_callback('layers', self._on_layers_changed)
self._on_layers_changed()
def selection_changed(self):
app = get_qapp()
if app.queryKeyboardModifiers() == Qt.AltModifier:
self.finalize_selection(clear=False)
def keyPressEvent(self, event):
if self.toolbar.active_tool is self.toolbar.tools['table:rowselect']:
if event.key() in [Qt.Key_Enter, Qt.Key_Return]:
self.finalize_selection()
super(TableViewer, self).keyPressEvent(event)
def finalize_selection(self, clear=True):
model = self.ui.table.selectionModel()
selected_rows = [self.model.order_visible[x.row()] for x in model.selectedRows()]
subset_state = ElementSubsetState(indices=selected_rows, data=self.data)
mode = self.session.edit_subset_mode
mode.update(self._data, subset_state, focus_data=self.data)
if clear:
# We block the signals here to make sure that we don't update
# the subset again once the selection is cleared.
self.ui.table.blockSignals(True)
self.ui.table.clearSelection()
self.ui.table.blockSignals(False)
def _on_layers_changed(self, *args):
for layer_state in self.state.layers:
if isinstance(layer_state.layer, BaseData):
break
else:
return
self.data = layer_state.layer
self.setUpdatesEnabled(False)
self.model = DataTableModel(self)
self.ui.table.setModel(self.model)
self.setUpdatesEnabled(True)
@messagebox_on_error("Failed to add data")
def add_data(self, data):
with self._layer_artist_container.ignore_empty():
self.state.layers[:] = []
return super(TableViewer, self).add_data(data)
@messagebox_on_error("Failed to add subset")
def add_subset(self, subset):
if self.data is None:
self.add_data(subset.data)
self.state.layers[0].visible = False
elif subset.data != self.data:
raise ValueError("subset parent data does not match existing table data")
return super(TableViewer, self).add_subset(subset)
@property
def window_title(self):
if len(self.state.layers) > 0:
return 'Table: ' + self.state.layers[0].layer.label
else:
return 'Table'
def closeEvent(self, event):
"""
On close, Qt seems to scan through the entire model
if the data set is big. To sidestep that,
we swap out with a tiny data set before closing
"""
super(TableViewer, self).closeEvent(event)
if self.model is not None:
self.model._data = Data(x=[0])
event.accept()
def get_layer_artist(self, cls, layer=None, layer_state=None):
return cls(self, self.state, layer=layer, layer_state=layer_state)
@staticmethod
def update_viewer_state(rec, context):
return update_table_viewer_state(rec, context)
glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/__init__.py 0000644 0001750 0001750 00000000223 13502206677 022655 0 ustar noahfx noahfx from .data_viewer import TableViewer, TableLayerArtist # noqa
def setup():
from glue.config import qt_client
qt_client.add(TableViewer)
glueviz-1.0.1+dfsg.orig/glue/viewers/table/qt/data_viewer.ui 0000644 0001750 0001750 00000003277 13502206677 023411 0 ustar noahfx noahfx
Form
0
0
742
612
Form
-
-
QAbstractItemView::NoEditTriggers
QAbstractItemView::ExtendedSelection
QAbstractItemView::SelectRows
true
107
false
true
false
TableViewWithSelectionSignal
QTableView
glue.viewers.table.qt.data_viewer
glueviz-1.0.1+dfsg.orig/glue/viewers/table/__init__.py 0000644 0001750 0001750 00000000000 13502206677 022222 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/table/compat.py 0000644 0001750 0001750 00000002572 13605357235 021767 0 ustar noahfx noahfx import uuid
from glue.viewers.common.state import LayerState
STATE_CLASS = {}
STATE_CLASS['TableLayerArtist'] = LayerState
def update_table_viewer_state(rec, context):
"""
Given viewer session information, make sure the session information is
compatible with the current version of the viewers, and if not, update
the session information in-place.
"""
if '_protocol' not in rec:
# Note that files saved with protocol < 1 have bin settings saved per
# layer but they were always restricted to be the same, so we can just
# use the settings from the first layer
rec['state'] = {}
rec['state']['values'] = {}
rec.pop('properties')
layer_states = []
for layer in rec['layers']:
state_id = str(uuid.uuid4())
state_cls = STATE_CLASS[layer['_type'].split('.')[-1]]
state = state_cls(layer=context.object(layer.pop('layer')))
for prop in ('visible', 'zorder'):
value = layer.pop(prop)
value = context.object(value)
setattr(state, prop, value)
context.register_object(state_id, state)
layer['state'] = state_id
layer_states.append(state)
list_id = str(uuid.uuid4())
context.register_object(list_id, layer_states)
rec['state']['values']['layers'] = list_id
glueviz-1.0.1+dfsg.orig/glue/viewers/image/ 0000755 0001750 0001750 00000000000 13752535025 020115 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/tests/ 0000755 0001750 0001750 00000000000 13752535025 021257 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/tests/test_pixel_selection_subset_state.py 0000644 0001750 0001750 00000005755 13605357235 030661 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import pytest
import numpy as np
from numpy.testing import assert_array_equal
from glue.core.data import Data
from glue.core.data_collection import DataCollection
from glue.core.link_helpers import LinkSame, MultiLink
from glue.core.exceptions import IncompatibleAttribute
from ..pixel_selection_subset_state import PixelSubsetState
def test_pixel_selection_subset_state():
data1 = Data(x=np.ones((2, 4, 3)))
data2 = Data(y=np.ones((4, 3, 2)))
data3 = Data(z=np.ones((2, 3)))
y_id = data2.main_components[0]
z_id = data3.main_components[0]
slice_1d = [slice(1, 2), slice(None), slice(None)]
slice_2d = [slice(None), slice(2, 3), slice(1, 2)]
slice_3d = [slice(1, 2), slice(2, 3), slice(1, 2)]
state_1d = PixelSubsetState(data1, slice_1d)
state_2d = PixelSubsetState(data1, slice_2d)
state_3d = PixelSubsetState(data1, slice_3d)
states = [state_1d, state_2d, state_3d]
dc = DataCollection([data1, data2, data3])
# Calling to_array with reference data should work by default, and not work
# with unlinked datasets.
for data in dc:
for state in states:
cid = data.main_components[0]
if data is data1:
assert_array_equal(state.to_array(data, cid), data[cid][state.slices])
else:
with pytest.raises(IncompatibleAttribute):
state.to_array(data, cid)
# Add one set of links
dc.add_link(LinkSame(data1.pixel_component_ids[0], data2.pixel_component_ids[2]))
dc.add_link(LinkSame(data1.pixel_component_ids[0], data3.pixel_component_ids[0]))
assert_array_equal(state_1d.to_array(data2, y_id), data2[y_id][:, :, 1:2])
with pytest.raises(IncompatibleAttribute):
state_2d.to_array(data2, y_id)
with pytest.raises(IncompatibleAttribute):
state_3d.to_array(data2, y_id)
assert_array_equal(state_1d.to_array(data3, z_id), data3[z_id][1:2])
with pytest.raises(IncompatibleAttribute):
state_2d.to_array(data3, z_id)
with pytest.raises(IncompatibleAttribute):
state_3d.to_array(data3, z_id)
# Add links with multiple components, in this case linking two cids with two cids
def forwards(x, y):
return x + y, x - y
def backwards(x, y):
return 0.5 * (x + y), 0.5 * (x - y)
dc.add_link(MultiLink(data1.pixel_component_ids[1:],
data2.pixel_component_ids[:2],
forwards=forwards, backwards=backwards))
assert_array_equal(state_1d.to_array(data2, y_id), data2[y_id][:, :, 1:2])
assert_array_equal(state_2d.to_array(data2, y_id), data2[y_id][2:3, 1:2, :])
assert_array_equal(state_3d.to_array(data2, y_id), data2[y_id][2:3, 1:2, 1:2])
assert_array_equal(state_1d.to_array(data3, z_id), data3[z_id][1:2])
with pytest.raises(IncompatibleAttribute):
state_2d.to_array(data3, z_id)
with pytest.raises(IncompatibleAttribute):
state_3d.to_array(data3, z_id)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 023363 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/tests/test_composite_array.py 0000644 0001750 0001750 00000011575 13605357235 026103 0 ustar noahfx noahfx from unittest.mock import MagicMock
import numpy as np
from numpy.testing import assert_allclose
from matplotlib.pyplot import cm
from ..composite_array import CompositeArray
class TestCompositeArray(object):
def setup_method(self, method):
self.array1 = np.array([[2.0, 1.0], [0.0, 0.0]])
self.array2 = np.array([[np.nan, 1.0], [0.0, 0.0]])
self.array3 = np.array([[0.0, 0.0], [1.0, 0.0]])
self.array4 = np.array([[0.0, 0.0], [0.0, 1.0]])
self.composite = CompositeArray()
self.default_bounds = [(0, 1, 2), (0, 1, 2)]
def test_shape_size_ndim_dtype(self):
assert self.composite.shape is None
assert self.composite.size is None
assert self.composite.ndim == 2 # for now, this is hard-coded
assert self.composite.dtype is np.float # for now, this is hard-coded
self.composite.allocate('a')
self.composite.set('a', array=self.array1)
assert self.composite.shape == (2, 2)
assert self.composite.size == 4
assert self.composite.ndim == 2
assert self.composite.dtype is np.float
def test_shape_function(self):
array_func = MagicMock()
array_func.return_value = None
assert self.composite.shape is None
self.composite.allocate('a')
self.composite.set('a', array=array_func)
assert self.composite.shape is None
array_func.return_value = self.array1
assert self.composite.shape == (2, 2)
def test_cmap_blending(self):
self.composite.allocate('a')
self.composite.allocate('b')
self.composite.set('a', zorder=0, visible=True, array=self.array1,
color=cm.Blues, clim=(0, 2))
self.composite.set('b', zorder=1, visible=True, array=self.array2,
color=cm.Reds, clim=(0, 1))
# Determine expected result for each layer individually in the absence
# of transparency
expected_a = np.array([[cm.Blues(1.), cm.Blues(0.5)],
[cm.Blues(0.), cm.Blues(0.)]])
expected_b = np.array([[cm.Reds(0.), cm.Reds(1.)],
[cm.Reds(0.), cm.Reds(0.)]])
# If both layers have alpha=1, the top layer should be the only one visible
assert_allclose(self.composite(bounds=self.default_bounds), expected_b)
# If the top layer has alpha=0, the bottom layer should be the only one visible
self.composite.set('b', alpha=0.)
assert_allclose(self.composite(bounds=self.default_bounds), expected_a)
# If the top layer has alpha=0.5, the result should be an equal blend of each
self.composite.set('b', alpha=0.5)
assert_allclose(self.composite(bounds=self.default_bounds), 0.5 * (expected_b + expected_a))
def test_color_blending(self):
self.composite.allocate('a')
self.composite.allocate('b')
self.composite.set('a', zorder=0, visible=True, array=self.array1,
color=(0, 0, 1, 1), clim=(0, 2))
self.composite.set('b', zorder=1, visible=True, array=self.array2,
color=(1, 0, 0, 1), clim=(0, 1))
# Determine expected result for each layer individually in the absence
# of transparency
expected_a = np.array([[(0, 0, 1, 1), (0, 0, 0.5, 1)],
[(0, 0, 0, 1), (0, 0, 0, 1)]])
expected_b = np.array([[(0, 0, 0, 1), (1, 0, 0, 1)],
[(0, 0, 0, 1), (0, 0, 0, 1)]])
# In this mode, the zorder shouldn't matter, and if both layers have
# alpha=1, we should see a normal blend of the colors
assert_allclose(self.composite(bounds=self.default_bounds), np.maximum(expected_a, expected_b))
# If the top layer has alpha=0, the bottom layer should be the only one visible
self.composite.set('b', alpha=0.)
assert_allclose(self.composite(bounds=self.default_bounds), expected_a)
# If the top layer has alpha=0.5, the result should have
self.composite.set('b', alpha=0.5)
assert_allclose(self.composite(bounds=self.default_bounds), np.maximum(expected_a, expected_b * 0.5))
def test_deallocate(self):
self.composite.allocate('a')
self.composite.set('a', array=self.array1, color='1.0', clim=(0, 2))
assert self.composite.shape == (2, 2)
expected = np.ones(4) * self.array1[:, :, np.newaxis] / 2.
expected[:, :, 3] = 1
assert_allclose(self.composite(bounds=self.default_bounds), expected)
self.composite.deallocate('a')
assert self.composite.shape is None
assert self.composite(bounds=self.default_bounds) is None
def test_noactive(self):
array = np.random.random((100, 100))
self.composite.allocate('a')
self.composite.set('a', array=array, visible=False)
assert self.composite() is None
glueviz-1.0.1+dfsg.orig/glue/viewers/image/tests/test_state.py 0000644 0001750 0001750 00000037002 13661230662 024010 0 ustar noahfx noahfx import pytest
import numpy as np
from numpy.testing import assert_equal
from glue.core import Data, DataCollection
from glue.core.coordinates import Coordinates, IdentityCoordinates
from glue.core.link_helpers import LinkSame
from glue.core.exceptions import IncompatibleDataException, IncompatibleAttribute
from ..state import ImageViewerState, ImageLayerState, AggregateSlice
class SimpleCoordinates(Coordinates):
def __init__(self):
super().__init__(pixel_n_dim=3, world_n_dim=3)
def pixel_to_world_values(self, *args):
return tuple([2.5 * p for p in args])
def world_to_pixel_values(self, *args):
return tuple([0.4 * w for w in args])
@property
def axis_correlation_matrix(self):
matrix = np.zeros((self.world_n_dim, self.pixel_n_dim), dtype=bool)
matrix[2, 2] = True
matrix[0:2, 0:2] = True
return matrix
class TestImageViewerState(object):
def setup_method(self, method):
self.state = ImageViewerState()
def test_pixel_world_linking(self):
data = Data(label='data', x=[[1, 2], [3, 4]], y=[[5, 6], [7, 8]],
coords=IdentityCoordinates(n_dim=2))
layer_state = ImageLayerState(layer=data, viewer_state=self.state)
self.state.layers.append(layer_state)
w1, w2 = data.world_component_ids
p1, p2 = data.pixel_component_ids
self.state.reference_data = data
# Setting world components should set the pixel ones
self.state.x_att_world = w1
self.state.y_att_world = w2
assert self.state.x_att is p1
assert self.state.y_att is p2
# Setting one component to the same as the other should trigger the other
# to flip to prevent them from both being the same
self.state.x_att_world = w2
assert self.state.x_att is p2
assert self.state.y_att is p1
assert self.state.y_att_world is w1
self.state.y_att_world = w2
assert self.state.x_att is p1
assert self.state.x_att_world is w1
assert self.state.y_att is p2
# Changing x_att and y_att should change the world equivalents
self.state.x_att = p2
assert self.state.x_att_world is w2
assert self.state.y_att is p1
assert self.state.y_att_world is w1
self.state.y_att = p2
assert self.state.y_att_world is w2
assert self.state.x_att is p1
assert self.state.x_att_world is w1
class TestSlicingAggregation():
def setup_method(self, method):
self.viewer_state = ImageViewerState()
self.data = Data(x=np.ones((3, 4, 5, 6, 7)))
self.layer_state = ImageLayerState(layer=self.data, viewer_state=self.viewer_state)
self.viewer_state.layers.append(self.layer_state)
self.p = self.data.pixel_component_ids
def test_default(self):
# Check default settings
assert self.viewer_state.x_att == self.p[4]
assert self.viewer_state.y_att == self.p[3]
assert self.viewer_state.slices == (0, 0, 0, 0, 0)
assert self.layer_state.get_sliced_data().shape == (6, 7)
def test_flipped(self):
# Make sure slice is transposed if needed
self.viewer_state.x_att = self.p[3]
self.viewer_state.y_att = self.p[4]
assert self.viewer_state.slices == (0, 0, 0, 0, 0)
assert self.layer_state.get_sliced_data().shape == (7, 6)
def test_slice_preserved(self):
# Make sure slice stays the same if changing attributes
self.viewer_state.slices = (1, 3, 2, 5, 4)
self.viewer_state.x_att = self.p[2]
self.viewer_state.y_att = self.p[4]
assert self.viewer_state.slices == (1, 3, 2, 5, 4)
assert self.viewer_state.wcsaxes_slice == ['y', 5, 'x', 3, 1]
assert self.layer_state.get_sliced_data().shape == (7, 5)
self.viewer_state.x_att = self.p[2]
self.viewer_state.y_att = self.p[1]
assert self.viewer_state.slices == (1, 3, 2, 5, 4)
assert self.viewer_state.wcsaxes_slice == [4, 5, 'x', 'y', 1]
assert self.layer_state.get_sliced_data().shape == (4, 5)
self.viewer_state.x_att = self.p[0]
self.viewer_state.y_att = self.p[4]
assert self.viewer_state.slices == (1, 3, 2, 5, 4)
assert self.viewer_state.wcsaxes_slice == ['y', 5, 2, 3, 'x']
assert self.layer_state.get_sliced_data().shape == (7, 3)
def test_aggregation(self):
# Check whether using AggregateSlice works
slc1 = AggregateSlice(slice(None), 0, np.mean)
slc2 = AggregateSlice(slice(2, 5), 3, np.sum)
self.viewer_state.slices = (slc1, 3, 2, slc2, 4)
self.viewer_state.x_att = self.p[2]
self.viewer_state.y_att = self.p[4]
assert self.viewer_state.slices == (slc1, 3, 2, slc2, 4)
assert self.viewer_state.wcsaxes_slice == ['y', 3, 'x', 3, 0]
result = self.layer_state.get_sliced_data()
assert result.shape == (7, 5)
assert_equal(result, 3) # sum along 3 indices in one of the dimensions
class TestReprojection():
def setup_method(self, method):
self.data_collection = DataCollection()
self.array = np.arange(3024).reshape((6, 7, 8, 9))
# The reference dataset. Shape is (6, 7, 8, 9).
self.data1 = Data(x=self.array, coords=IdentityCoordinates(n_dim=4))
self.data_collection.append(self.data1)
# A dataset with the same shape but not linked. Shape is (6, 7, 8, 9).
self.data2 = Data(x=self.array)
self.data_collection.append(self.data2)
# A dataset with the same number of dimesnions but in a different
# order, linked to the first. Shape is (9, 7, 6, 8).
self.data3 = Data(x=np.moveaxis(self.array, (3, 1, 0, 2), (0, 1, 2, 3)))
self.data_collection.append(self.data3)
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[0],
self.data3.pixel_component_ids[2]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[1],
self.data3.pixel_component_ids[1]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[2],
self.data3.pixel_component_ids[3]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[3],
self.data3.pixel_component_ids[0]))
# A dataset with fewer dimensions, linked to the first one. Shape is
# (8, 7, 6)
self.data4 = Data(x=self.array[:, :, :, 0].transpose())
self.data_collection.append(self.data4)
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[0],
self.data4.pixel_component_ids[2]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[1],
self.data4.pixel_component_ids[1]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[2],
self.data4.pixel_component_ids[0]))
# A dataset with even fewer dimensions, linked to the first one. Shape
# is (8, 6)
self.data5 = Data(x=self.array[:, 0, :, 0].transpose())
self.data_collection.append(self.data5)
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[0],
self.data5.pixel_component_ids[1]))
self.data_collection.add_link(LinkSame(self.data1.pixel_component_ids[2],
self.data5.pixel_component_ids[0]))
# A dataset that is not on the same pixel grid and requires reprojection
self.data6 = Data()
self.data6.coords = SimpleCoordinates()
self.array_nonaligned = np.arange(60).reshape((5, 3, 4))
self.data6['x'] = np.array(self.array_nonaligned)
self.data_collection.append(self.data6)
self.data_collection.add_link(LinkSame(self.data1.world_component_ids[0],
self.data6.world_component_ids[1]))
self.data_collection.add_link(LinkSame(self.data1.world_component_ids[1],
self.data6.world_component_ids[2]))
self.data_collection.add_link(LinkSame(self.data1.world_component_ids[2],
self.data6.world_component_ids[0]))
self.viewer_state = ImageViewerState()
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data1))
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data2))
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data3))
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data4))
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data5))
self.viewer_state.layers.append(ImageLayerState(viewer_state=self.viewer_state, layer=self.data6))
self.viewer_state.reference_data = self.data1
def test_default_axis_order(self):
# Start off with a combination of x/y that means that only one of the
# other datasets will be matched.
self.viewer_state.x_att = self.data1.pixel_component_ids[3]
self.viewer_state.y_att = self.data1.pixel_component_ids[2]
self.viewer_state.slices = (3, 2, 4, 1)
image = self.viewer_state.layers[0].get_sliced_data()
assert_equal(image, self.array[3, 2, :, :])
with pytest.raises(IncompatibleAttribute):
self.viewer_state.layers[1].get_sliced_data()
image = self.viewer_state.layers[2].get_sliced_data()
assert_equal(image, self.array[3, 2, :, :])
with pytest.raises(IncompatibleDataException):
self.viewer_state.layers[3].get_sliced_data()
with pytest.raises(IncompatibleDataException):
self.viewer_state.layers[4].get_sliced_data()
def test_transpose_axis_order(self):
# Next make it so the x/y axes correspond to the dimensions with length
# 6 and 8 which most datasets will be compatible with, and this also
# requires a tranposition.
self.viewer_state.x_att = self.data1.pixel_component_ids[0]
self.viewer_state.y_att = self.data1.pixel_component_ids[2]
self.viewer_state.slices = (3, 2, 4, 1)
image = self.viewer_state.layers[0].get_sliced_data()
print(image.shape)
assert_equal(image, self.array[:, 2, :, 1].transpose())
with pytest.raises(IncompatibleAttribute):
self.viewer_state.layers[1].get_sliced_data()
image = self.viewer_state.layers[2].get_sliced_data()
print(image.shape)
assert_equal(image, self.array[:, 2, :, 1].transpose())
image = self.viewer_state.layers[3].get_sliced_data()
assert_equal(image, self.array[:, 2, :, 0].transpose())
image = self.viewer_state.layers[4].get_sliced_data()
assert_equal(image, self.array[:, 0, :, 0].transpose())
def test_transpose_axis_order_view(self):
# As for the previous test, but this time with a view applied
self.viewer_state.x_att = self.data1.pixel_component_ids[0]
self.viewer_state.y_att = self.data1.pixel_component_ids[2]
self.viewer_state.slices = (3, 2, 4, 1)
view = [slice(1, None, 2), slice(None, None, 3)]
image = self.viewer_state.layers[0].get_sliced_data(view=view)
assert_equal(image, self.array[::3, 2, 1::2, 1].transpose())
with pytest.raises(IncompatibleAttribute):
self.viewer_state.layers[1].get_sliced_data(view=view)
image = self.viewer_state.layers[2].get_sliced_data(view=view)
print(image.shape)
assert_equal(image, self.array[::3, 2, 1::2, 1].transpose())
image = self.viewer_state.layers[3].get_sliced_data(view=view)
assert_equal(image, self.array[::3, 2, 1::2, 0].transpose())
image = self.viewer_state.layers[4].get_sliced_data(view=view)
assert_equal(image, self.array[::3, 0, 1::2, 0].transpose())
def test_reproject(self):
# Test a case where the data needs to actually be reprojected
# As for the previous test, but this time with a view applied
self.viewer_state.x_att = self.data1.pixel_component_ids[0]
self.viewer_state.y_att = self.data1.pixel_component_ids[2]
self.viewer_state.slices = (3, 2, 4, 1)
view = [slice(1, None, 2), slice(None, None, 3)]
actual = self.viewer_state.layers[5].get_sliced_data(view=view)
# The data to be reprojected is 3-dimensional. The axes we have set
# correspond to 1 (for x) and 0 (for y). The third dimension of the
# data to be reprojected should be sliced. This is linked with the
# second dimension of the original data, for which the slice index is
# 2. Since the data to be reprojected has coordinates that are 2.5 times
# those of the reference data, this means the slice index should be 0.8,
# which rounded corresponds to 1.
expected = self.array_nonaligned[:, :, 1]
# Now in the frame of the reference data, the data to show are indices
# [0, 3] along x and [1, 3, 5, 7] along y. Applying the transformation,
# this gives values of [0, 1.2] and [0.4, 1.2, 2, 2.8] for x and y,
# and rounded, this gives [0, 1] and [0, 1, 2, 3]. As a reminder, in the
# data to reproject, dimension 0 is y and dimension 1 is x
expected = expected[:4, :2]
# Let's make sure this works!
assert_equal(actual, expected)
def test_too_many_dimensions(self):
# If we change the reference data, then the first dataset won't be
# visible anymore because it has too many dimensions
self.viewer_state.reference_data = self.data4
with pytest.raises(IncompatibleAttribute):
self.viewer_state.layers[0].get_sliced_data()
self.viewer_state.reference_data = self.data6
with pytest.raises(IncompatibleAttribute):
self.viewer_state.layers[0].get_sliced_data()
def test_update_x_att_and_y_att():
# Regression test for a bug that caused y_att to not be updated before
# events were sent out about x_att changing.
viewer_state = ImageViewerState()
data1 = Data(x=np.ones((3, 4, 5)))
layer_state1 = ImageLayerState(layer=data1, viewer_state=viewer_state)
viewer_state.layers.append(layer_state1)
data2 = Data(x=np.ones((3, 4, 5)))
layer_state2 = ImageLayerState(layer=data2, viewer_state=viewer_state)
viewer_state.layers.append(layer_state2)
def check_consistency(*args, **kwargs):
# Make sure that x_att and y_att are always for same dataset
assert viewer_state.x_att.parent is viewer_state.y_att.parent
viewer_state.add_global_callback(check_consistency)
viewer_state.add_callback('x_att', check_consistency)
viewer_state.add_callback('y_att', check_consistency)
viewer_state.add_callback('x_att_world', check_consistency)
viewer_state.add_callback('y_att_world', check_consistency)
viewer_state.add_callback('slices', check_consistency)
viewer_state.reference_data = data1
assert viewer_state.x_att is data1.pixel_component_ids[2]
assert viewer_state.y_att is data1.pixel_component_ids[1]
viewer_state.reference_data = data2
assert viewer_state.x_att is data2.pixel_component_ids[2]
assert viewer_state.y_att is data2.pixel_component_ids[1]
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/ 0000755 0001750 0001750 00000000000 13752535025 020541 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 021703 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/test_python_export.py 0000644 0001750 0001750 00000006512 13752534424 026244 0 ustar noahfx noahfx import numpy as np
import matplotlib.pyplot as plt
from astropy.utils import NumpyRNGContext
from glue.core import Data, DataCollection
from glue.app.qt.application import GlueApplication
from glue.viewers.image.qt import ImageViewer
from glue.viewers.matplotlib.qt.tests.test_python_export import BaseTestExportPython
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 assert_same(self, tmpdir, tol=0.1):
BaseTestExportPython.assert_same(self, tmpdir, tol=tol)
def test_simple(self, tmpdir):
self.assert_same(tmpdir)
def test_simple_legend(self, tmpdir):
self.viewer.state.show_legend = True
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.legend.visible = True
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_legend(self, tmpdir):
self.viewer.state.legend.visible = True
self.data_collection.new_subset_group('mysubset', self.data.id['cube'] > 0.5)
self.assert_same(tmpdir, tol=0.15) # transparency and such
def test_subset_slice(self, tmpdir):
self.data_collection.new_subset_group('mysubset', self.data.id['cube'] > 0.5)
self.test_slice(tmpdir)
def test_subset_transposed(self, tmpdir):
self.viewer.state.x_att = self.data.pixel_component_ids[0]
self.viewer.state.y_att = self.data.pixel_component_ids[1]
self.data_collection.new_subset_group('mysubset', self.data.id['cube'] > 0.5)
self.assert_same(tmpdir)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024007 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/baseline/ 0000755 0001750 0001750 00000000000 13752535025 023465 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/baseline/test_resample_on_zoom.png 0000644 0001750 0001750 00000513646 13502206677 030622 0 ustar noahfx noahfx PNG
IHDR t
sBIT|d pHYs Ԃb IDATxgSU[}Q2 "APPq$Q欘@1gEE(F@QI$gH ())ѣGPSSeee )**А줡yyys@߿ؘ_"!!^OOFCOOO|O?Ȉvˑ###ѣAee%())a``@~~>]]](((BUU477#Ԥtuu'BmmmZZZ]WWGss3]]]PZZ߾}_~GKK Eyy9zUUU$$$hkkC$Ԅhkkjjj ***PTT }}} Z[[caaAaa! z~dgg#++>tuuQ\\H$BWW2(.. ~HIIASS"P2JJJBCC}E$FYY괴 AII YYY*++ꢱ6z쉒455!--gΜ!##-ZӧOYh ;v7o'XXXpA&MDgg'}!77 &qFrssٿ? 477#
=z4zbʔ)ȰuV-[FII fĉ+ ܜaÆkf͚Eqq1AAA}ٳg&ոN~~>_ ̷o1b())~z
E(2dۙ9s&zzzl۶G 1m4tuu9s >>>SQQ-wwwY`fʔ)l߾ eeeƏ C ɉ72sLnܸܹsqvv֖w1vXvލ%^^^dffݻѡ---ƍGPP[n///~Aee%ΝCMMFVXʕ+QWWۛ| 9B^|$^999-[Fvv6"ԩSlٲ)))~zpqqaÆQXXHmm-sΥ;v,VB ;v@VVƍɇ Xb#))7k֬!66. =JQQJJJ(++={DQQf̘Aff&&&&Y{{{ 87o
eԩtuuqJKK777JKKY|9Gfȑ < X~=>}pvvf,];w3
߿ޞիW`:;;)++ڵkHIIի
͛7imm%##דƩSX`RRRsa>} 8iiiqssctttzjZZZ"<<<8|0ՋR?>[nsssvhooGYYE/fΜAp߿)S >|8>>>8;;cbbBmm-qqqHJJRUU ^^^R]]͋/HKKC!!![hllDMM/˗/CZZ dee ::<&L@ee%fffZxLLL}6 hjjeoN{{;ӧOG(riV^IMMp֬YCKK QQQ455˵k
ŋaccC{{;222 <߿3w\222!== 555*++9~8fffߟ61у}ٳ{{{.\@kk+3p@RRRX|96l`ҥ҂;DEEC߾}s---J^^ ܸq###رc***hhh
aڵDEE舉 %%%xzzrA֯_ϴi
̝;t$%%?Ǐlذ+Wra ;7 =B m6jkkٸq#Ϟ=Ǐr8q"L8W^ k._>>|'O'yرcdԨQL8kaffF>}pwwߟ`fΜɀx9666x(
ľ}pqqܹsx{{3ydzL8rJrss̜9G"//ϩS';;ׯ_3x`jjjxǏcr%-[O>%..L6oׯ&))`jkkׯ fff477 ͽ{֭[!C÷o033Nyy9 <@__}# BYYC > 999سg ._R\\7\vl055eȑL45kP\\L\\ kø@rr2Bdeey&F |
F`` =z֭[lܸ^zN^^ UUU 4O1b-OZZZ
III8s Æ
CJJ1cưa:t(ZZZꢫ-B$ /^[BNN|{FVVK,᯿bXYYq}#y : O>eŊ| 6n܈:u
{{{jkkQWWg\~PϟL8#G ?Chh( =Ϗ3gcKhh(,Y ֭[ NNN\vm۶1m4CMMlllhjj 06oLHH~~~tttp5&''fy%gҥKgή]x5144DGG---xo&55 IJJbĉh֮]=())Lmm-R\\>>>ܿB!accCgg'RRR 2$$ !CBFFRRR;;;6l222|___߿Ͼ}>ꢺ|9{,Ϟ=cٲecffÆ
cΝ.7bccQTTׯ_D\\ αc000@[[1o<455=SSS틧'455zjҰ۷bhhHjj** =zĤI000`ԩ455accCmm-G ʕ+;}ѣϬ3f`mmMBBYYY,ӻ1cֆ:::l۶
HDFFKQQŤJZZRRR1h ?Α#Gċjjj\z߿s7"@˗/
ׯ_S^^.$ $--J<==)++А>}0` 6nȶm˗/7gϞ DFF2x`JKK8p ̞=[?| &ѣG9<< [[[dС<\ alݺ'N0n8N8&^^^̙3777>|y QQQL4 ''':::b֬YDFFrYqϥ@@EEJ5)===&N
QQQ!>>[nALL qqq$&&b``͛gڴih"fϞ&Mk2}t,--ill$..sss 0220ٽ{7hkkׯYhϟ',,zy ׯ_{+++:::ظq#6mӓ4㱲"..Çsaptt$%%}}}c#++K`` _F$xbvIUUΝ#33{& tfΜߞ:u*NbСRSSbҤIX0`혚RPPP($77)SpYϟOCC...DDD!nEDD؏nkԩSݻw =₩)wF ۷x"ⅸ#FPTT>K,aҥ,Z &ʼy6mAAA |$={Wddds455Ņ'O sIx=VBUUVN>۷3gcʕHJJ=$''cjjJ\\ fffhkkՅ
[[[3f ZZZajj4###Ï ?Ɔdill˗/p`` XXXPRR& @l)1zh|`yxyy̹sXr%***ܽ{
DL2:xB:QVV7 '3f̠ ?~0vkv葑L<ɓ'SPP@ݻ7" ;vrJTUUg̘1Xs qvvFUUxW^%((|bbbX`#G۷oƊG 1eIIIAWWD?y!'OԩS̝;PH$">> ''' **
MMMHFFǏG(ԩSٰa
HJJruә;w. 0'Ni&zIJJ
BBB?d֬Y`lly| ppp| HLLd̘1 > Μ9)))7o`ll̷oXx1 DCCCСCIHH`ɒ%_EӣCˉ'zx!y=
SUUŝ;w8x ܹ<
6l999BUU111<~}}}郅 HJJbɒ%|bbbҥK˓:::X[[c4hΝݝ$$$ 7nԔ,V^ XZZ"!!i8<Ϟ=Ǐ `bb7X|9"++Kuu5~~~)NU}/_HSS
{{{m֭[G__Ǐ #8p Ʉ `ȑ :777U9ՋG3ؾ};|CCCكV˗/ׯ_`kk oDGGChh(JJJx{{}vݙ8q"\|ɓ'sN >|~ `bbԩSѣ ߿KNNwˋ x%)))y& Ɔsαxb122֖G ƍeȑL0N>y&
ڵk,XjjjhjjyyyXbFFFzZYh <\͛7̜9aÆ ILL3rH jjj&<<\ܠÇW#SL///OliiItt4
133@ 1x"+Vŋb˖-0|p d̙b833u֡ɓ'pww֖>}p HLL[YYYBƏ ϖ-[x)ׯg̙߿A!
߿̙3l۶zf͚ř3g5k蠬ɓ' ARR#G l̙Cff&WqݻwoZZZ#::---͛ñ-[ ;bܹxC{{;1~xrssYlFFF燡xGg
ʕ+#;;@ӧ&L͛ :t133ܹs>}---rrr?>Æ
#>> llla
DKBB̟?< i-[HYYCx ,tuuq"##/:dgg#))IBB9997EEEIKKC___HIIq=v
`_ >[laٲeS[[ܸq???{{{
ӧOӧqAPSSɉߓBP B
D\]]s >d
x)ϟyyy; h IDATׯ 666j'--}FFF(((ix1&&&̙3UUUrssbժUKzz:ZZZl2QPPA\U-FFF
g֬Y}:SNEUUӧettt3^3g0c V^MFFKKK\\\GSSp177'%%CCCy3f̠gϞ␕%((###ŋYz5顮ׯիL>cdddHJJɉׯ_ٳF<==dȐ!ǜ9sx!?DUU =z0i$qww$$$pttzIEEqqq\|*_n̙33p@._̮]HOO֖. <{yC^^ eee 9R =z4 < SSSbcc2e
(++s=tttصkL6Ml622]vH||~L4]vQSS)**bС0almmbԩS{GGGΝӧ6m`ffFgҤIo>Ο?)
ѣG?> :rrr`رl۶
]]]ݻ(**ۛ?NA?qsttt999ܾ}s璕şYv-cƌ!$$4|||
ʹiӰȑ#"())AEEEHHHی7@TUU>|8߹~:3c KvvyX\\ 666{n222>'N$55###͛GZZē'O(--%>>_qssX[[_qux'̚5
6l@zz:7 Gӧ3f \pbٻw/cǎE$ʵk9r$Q__Opp0Jcc#rrrtvvr/_2h N</͛70j(|}}D[[RzIqq1***lٲ### @ `֬YHHHPRR7oޤ7np-RRRHJJB$IYY˗/А3gpi֬Yógϸz*fgg' ,@QQ
:;;y1yyy\p4/^H$b˖-_AA
^zEQQx{{3uTqnzر:ur6lpo͍{q x
? &p!l'000WWWL:C}v={6| ?~ Nuu8LУG H߾}ӧϞ=Q\U\z%%%233Yr%K.%""|۷3zhٳ' GGGq˗/Z.dee4h˗/'//Ǐ+;OOO`III}eeeF% jg˗/TTTп9{,{ ''HĬY033#%%|sM ˋ0f̘A>}غu+6mBSSZOϞ=y1G &?? kkk233ҥK 6 ---Xt)1~x allLDD())쌜 "7ncK,2J
5h߿O =ӧl9sPZZRLLLhjjǏa& ?~3***QZZJLLaРA:u
y&ʶm8tϟ?ߟV\ɥKHNNȔ)Sӧ0p@\8Z[[ X[[SSS/_GAKK 2k,~IAAٳ'ܸq߿ܺuϟWpppԔѣGwjjj =z͛7s Xn ;wСC\|PPPÃu֡Ǐ Yf
',,s֭[hkkA||<Ǐ חDdeeIMM%773fgۇ7˗/gӦM1_d۩dԩ,_`֬Y۷oĄǏcooODDǏ lll8{ⶴ Ă ?u?~ ?? ///)**ܹs,[ jkk͍ϟ?C[[+WQ| 7III#
qttd۶m\tT6nȆ
ppp@QQ'Oڵk`p]ӧO˗ΎÇ{={ƈ#PQQxyyOLLL~:SN͛7̤I߿?dddKR***"--@HMME[["2{l<==y[(
m۶cFСC9}4`hhHϞ=9y1b&&& <}ѣG~@ ޞB JWWʔKBBdeeѫW/Yn 8Ydd$---"xx
qnʕXXXPYYɘ1cgTTTpanIJJ
YYY̘1bV\I =x-2221 =zp58q"vZuܽ{{ӳgO֭[AggW^aee+.]Ãŋɓc$***?rР ~ׯ_qqq
Y`YYYp=ddd
Ę1cĶ4ܾ}CCCxxǏ DFFՅ*߿gxyyD}}=gf
xb'1|Bvv6 w|`VZEDDLvə3gՕ?߿O۷
<ȫWHJJ"99jkk?~>bf͚ȑ#illd| ?2|pvލ ?~ӧǗ/_4hvvv{N|8wD, ,Z7o ##CVVahlld˖-ߟ{Sjkkɡ߿MAA999 ##27oΎW^̐!C1b"ߋG\oH(KGG 111XZZAgg'渻F}}8*۷oqqq!--m۶qi Bqaii.JJJӧO RSSy=mmmΜ9' Q555,--ɓ 8)))~ͻw y/ό ;ߋu1cXZZboo8H`ggGCCYYY<}v ;pm"##yUUUܽ{sUb
ܹeee>}ٺu+nnnOfС<|&
BAA000 <==1b
3j(ܜ;wDVV3g$33X֮]K^^ oAGGDlmmΎaÆQ^^NXXxn9r$zgϞ߿DLLL͍` >|Htt4%%%DDDnѣ˅\uĈBI,twwgtttׯQWWgj****pzzz\pÇ IIIؠǙ3gadffbhh>O}:222y_tRÃX HPPO>EWWL\\ V N{ܹsHHHP]]MHH&::Zk/{/hkk666ٱsNrrr8}4Ϟ=ʕ+磧GEEK,IHH+VtR1ի쌫+<;G.t QUU,ڐ*U IDAT&..uuux $$$ƍIKKcÆ
lݺccc ±c8q0tPRSSҥK*FFFjooGNN߿3yd9y$MMM8;;;222~{rY6o 8撒y%7QQQR)))aÆ
HHHMrr2>}gϞƜ9s甕j*o
߿se@MM
LLLsɼ{
9|0燏 ?~ <Ǐ ztt4ϟ?dӫW/"##
:N>6}JKKАvlmmqww'66333tttקUESRRBVVaÆɂ 1c߿,Z???ZXXczPVV'NkɓIKKcʔ) >|߿o^x 8p@~ III 9]v7n VVVɓ'ǚ5kԩSb9p@ ;&pmmmhiiaƌzݻw#!!`Ќ1 &P[[ׯ_PpqttwԄk֬ӧɛ7oTTTceeo^JSS-i&8{,ҸR]]M~~>;w̌BTUU}6BvqhnnҒ{1i$KϞ=Y~=K,AJJ$,,,CMM۷oSWWyjhh0oq ϟϵkPVVȑ#dgg3c ..\@RR___jkkill3grqQVVL8l ֭ӧOٙ/"//֭[y9˗/'''&L+W]+(--e۶m}5lY:vvv --M@@H:u* =b㫧'555L0 bii) =bڴitttp-455ҥ ***EѣG7o $''ѣG5jUUUƌCAA>}ԔC ҵkɨw\\\x=-BRR\\\x9:::ⴡS - XK.ѣGLBXX1c 9GEEq%n߾rrrKjjjߟ/_ү_?vAEEMMM!---vMs MMMlǏ S^^ɓ3f 7oߗ
oiرcիWSUUٳ9s&,Z''',-->}:[n?!CSĈ/9" ݻwܹs)**bH }6ܿ9~8Oرclذ
jjj())f ʠA֭keǎ )ڲe ttt˾6{ȑ#lݺ lllHMMe֬Yz
kkk > ?&3386mDaaX .]TࢣٳgC(((ݝ'Oyf\BEE~ wn1c055%;;ccc >| ="))
IOOݝ GRR]v
Dii){nY`#F ;;ׯ_ӥKdذa|[nK}}=^^^,\G2aݱTDur=ƍoǏL0pʘ2e
s7o :::xyydy%#F &&srJˣK. 06055E]]]Ґ~%ϟ?g̘1|礧s%&Oƍ"IcnnRRR۷#FK
9}>}N|>}x`AJJ{sU{ƍ߿?VbBellѣׯ \zUpݻʕ+)//)Q塧GncyZJıߟ%KPZZʈ#رc+WΝ;ݛ ?~Bxx8sE]]7np98p vvvܿ sssʸw JJJHKKS^^N]] 4Ç{n̙ 悜w!gӓL;eee\\\(++J@L:!C ''*}ӧOtRMǏ7~x;ѯ_?V3m4 >̏ ?ppp Z;w)Bܹs߿xqd&33CENN"'K,̌/_bkkK@@ &&&dggs1ƌ# gN||< \reeev˗/ =z$ ~<ܼy7oPYY͛APt" 9x }Xȝ;wGFF >̺uDe~ >$''^zORRTTT̆
1b ё߿ӽ{wZZZD
ҥKCUU $%%ƍqe<==YjК/XիWy }I&n:|||w 111̘1|}}100\lIII8p RRR
7nDt]ȈdٳgX[[yfַo_ 9Bee%]t᯿"--Yf닭-ddd"˖-cƍ'rssYb Ǐ ^;;;
ׯӧ{졾ӭ[76l@Ϟ=QTTӯ_?y ...ܹ7o2zhJJJ(++ȑ#Y[n1m4@MM
@CCC8;||||2SLٳg888`ccÎ ;W^䄟 ;v GGGV---֖}ĉy1#!!. >|?]&66XN~bذa̙3۷ =z>},Dii)uuuTUU+RRRL4REAw/V0#ϑ#G ٙBCCINNG 1|7ѣGrM4i={{{{t邷7 ?P122?HAAָWKhh(ϟ >|sy/^Lvv6_X(FŸq8|0<}#GPTT ߑ.6///;v,GMMvN82 @OOUUU
ƤIDԙ?УG~͡C ?S%tttHOOgšƍAIIӧOSTTĐ!Cׯw ovƔ`kkˡChmm)@999+TVV
ʕ+2d ;v ;;;F W^kq!xM8x XZZb
b 3gӧO ?~p5j6l%%%Ǐ ӧO<{ 555~7 <ȑ#",9--_lܸse(**"33ѣGiӈ@^^x>~H^ĉD^ꎎ,xyyѻwo]XرG
ȑ# رc ? ϟOGGB|ǏsQ|}}f֬Y :twwwRRR8p mmm<|YYY}6QQQDGGӻwo$%%ի***,]Ll4ifԩ ɓ'OD"K.ɉfHII[n(++cdd͛7fNjHHwޥW^qg{UVakkǎ C]]#GN^^ =z 99" 9u$&&rJX| =z4ZZZ,\{{{ .^h@~MLL ӧOGEE999֬Y#={˗qss_~yr"""ͥH\
1/^Օ z职 'ODIIׯ_3sLy#B=&O̥KPUUeԨQڵPnܸAxx8vvv#''Nj/3gׯ'55---ٷo C^^ׯ_#++Khh(AAA|ٳgAy =Z,_xڵkIJJBEE
s8|p8w HHH0sL >|߯w^{A߽{Iw'O燼< ?~vZ[[:t @͝;?|IAA&L`ɒ%ٳGt`}}}ݻ7ųgԩSB@ZϟOZZlٲ[[[illȑ#,]@Yz5?˗/jt֍]XB͚5K}đ#G1c߿GNN*MFTTs}\ Hkk+ǎ #88-[ ++ jjj 0@}044$11+WS_{ۗE.,,d̘1w^tttxY =zjZ[[kx IDATGGG}իWٳ'ڵkIIIaȐ!"JEEK.@VV ^[[̞=W^ѭ[7ٽ{7999}v
Fss3NB[[%K0e틃9998;;Dyy9{x{{sN
͛#~z>~
EĜ9sgҤI^~M^^ %%%455QZZ~~~ ?~K.Dź hkk yp'ڵk### =ʩSHIIA 8ÇN,'O˗/lذG 1x`155qqN͟q ۇ Æ
cǎ 8::rI"""BWW߿ODD <4f̘3gXbSLӧO$B.\( ,@AA{1rH^zŵkprr\zÇw^3//l 1#ＺvJmm 55g٥Jn8{,O>ܜݻ=cǎ qqqlذHr f̘!:& ;Fqq1 cǎ%>>Caeeży022bͬ[ 'R{.x{{ʋ/5kNwﰳCZZ{{{lllҥ EEEb+...ddd F˗/3h ʗ/_}6:u
eeeQQQXXX%flܸQ,8q"9e899 ~vvP7\|cǎѧO GRR $%%3f 477DNN >ӧOpUnIaa!|ltuut455# ;vϟIIIASS999:qvvA !KܹkYx1 >|+WPYYĉihh`
L>TUUQWWݻw̞= ._{~Ŋdgg3m4<<iooׄ0bg}ĠA(++`Æ
љ;w.s1VPP`3sL.\@ii)222TTTũ֯_:fffDuu5퍹9 zzzl2ʄz ʸv7n!:R aѢETTTz\\ $%%abb
z"'''O74448;;En8~8>>>8;; XQee%xjMF݉GyuVpuueܹ";;wpEҩ7*QTTϟ Ο?ό38|0~ tBRRuuuacc1b_t ]]]/MLMM)//]]ZZ*7n@VV}!++<ݺu#44;333zC1czzz466ϠAPQQׯ@KK ddd ''̞=2Q ݙ3gn ##e˖ :V(((K.l2~իW3//ht|}}QQQAAABqRRRx)YNN cccرc)))֭[GBB%%%lڴcNJ`AQQQb;]#$$bΟ?uXYYqU<<| gΜAFF(y9k%88 ).. 0ҥKٳGy#~_QQ^zq%Qknnfĉ|EȎsssڵ+riFJJJ9
*I7KMMG 9r???"$I/3f TVVzj>Ν;j*#lFjj*+W%K˗-44 >:ZVVP p})((`yLX]]Aq%>&LSSS =zDbb"l2,--ѣG3rHIMMKKKkwwwٳٳg>^ɓ>>Ell, TVV믿7o
EEE푔DKK,8twFFFaÆ1rH;w.'Oɼyƍhkk3|pJJJ6!!-[Frr2➩
A#{tt4uuu
n穩aܹhhhヹ9/_dРA <333aSQQaڵMnx- >R^^N\\ ,\ooow xxx ++K]yׯ_1D444hIII#88XufꊐŋLTT ag͍_܌# s8q;;;a`_~Gqq1zzzӇ|6mD``vtt{4447vvvSyyy$$$[ڈd{Ԉ]pss3&&&HHHF``𗤥1i$ PSS#77W6v:JII1}t2d>}bʕDDDtR<{ IIIXv-gݺu b.M?{u] >/^Ú5kPUUɓHHHhMM
888> 8piӦq{GKK w念xzIii0iiiQTTDPPjjj"$ݝy1j(ك7%%%X[[7 8+Ǐ O]] Æ
CVVvŏ ?8q" 4O>CmFDDlڴ Μ9[ڵ+n [[[BCCFFF߿QPP@FFB{Gdd$]t|ݹs'FFF̘1'OO,--ٳgQQQxxxc:::PUU<֯_O>}(..ֵk%NNN<TĔ)Shii5PPP 77+++.\@FFC aС)))!??_ۉՕm۶amm5C *3gOܹ×/_000`
={r;w.wp Ғsmz-^ | 997bllL`` W\Ύ_~qQ:t(tڕxѡlll˗(((0j('W\֖9s0a
ŋ())!++Kvv06EFF2c ;v,^BMMM#555S^^߿155_~1}tVZEϞ=9tHb̟? eeeRRR8{ o兏/,?\Ri.MQR(d ɐydȜ).C%C(L2RII4x6չֽ7eÆv~z 3f@AA###߿QPP@x@ٱcSN͛7(**2zh,--y:gff
wx*bܼy IHHQ777Ξ=˦M055eʔ)7LMM}:ѣٳ'''vͬY0223 &Э[7aÆ
2L;wHOO'$$={`bb+/^6455qpp`˖-|]ރؽ{7555 6߿sy-Ǐ'++K$B~I]122b"ѱ#GbhhHuu50` rss###lBbb":::Mee%K,!33%Kl2GQQ#f湹eܹsgdeeʢϓ'Oسg yyy UUU#JJJ|KKKYz5/ BTTgf̘1 ;v iii<==9s& -Ѫ*VZ%Mƽ{(..FBBm۶ LBB ,@UU$jkk2e
ϟ? uuuxyyÁ>^^^1tP]ѣGlڵl߾:*++y-se<}˗#%%ڵkٴiO>EOOOĉIKKٳL> >p u111ԠƪU6l(R|R~477si͑qeɓ <-[PTT5yyy4uTΝKii)\r[[[RSSF__K.1n8QTT$!!'''ikkΎJPP{gϞQSS#Bבi
e
hjj|rmϟ;/_ݻOONll,DGGcbb³gXz5.]E RSSYp!у$=<|ܹsQQQ!$$}}}w }ϟyyyh-**buh*{Ill,_& ۷ӷo_щҹsgy%SQQXߟk2n8Φ^2336l&M3|pgԨQx@9x Ofݺur!6n(#uuu"m0rH?κu?~`e? uuu;w 8v턄`kk2Bzꅌ &&&!))@(߿ WWW:z(
-ϟ?v ܾ}v055ٳg~EEEx"sѣG<#F-4 >%%%w 0qD ?~CΝ; N*'O&55" Hvv6FFFhkkaLMMINN`ԨQoooXr%***"nccÅ ̟? ???`dddɥKd͚5bjjJMM`y'%%GNZZ߾}VtTGϟ?:u
$%% (**bgg' `ݺuWp[Ο?Occ#EEEݻwL3ڸq#Myy9,Z___ |8{+++Н;wժпq 733CWWƏ OBB... ,oƍtڕ\fϞÇݻlܸJ^+˖-ӓbp IDAT昇
Ȏ899S"""ܹ3 =ɉΝ;SXX"ǏG__w߿Ͽ:zbhhhpe233)**BOOIIIn) h{{{Չŋlذr ?.Th&&&Z)SPVVFkk+b
vICC@̛7 /_?p1ԩiii 6lmm9p cǎɓ'$''[vɭ[gyVXgHIIaȑ())QVVǏnyTVV¹s/_ԄKZZfffhii؈
;vي
\]]x"?˗HHHIPP>>> 'fff&3fܸq?c~~>ֆ555b[n{Nxc=<<Ǐ ߿߿QSScРAdeeORVֻwo۷/Ν#;;cccyիW;v,[lؘ;wĠA8<!##۷y Ӈ'rA*++'nBUU+W}v4JJJKGi)//:&O5555Jؚ:j*'-lܸQ=<fff1c yI&ɓ'E: 555|||ooo~Arr2~~~ձg PQQ۷?sȚ5kCSSSn݊gΜTu PWWHYBB%%% 8EEElllx9̟?T >\$*jjjР ʙ3g)7oޞ5k֠5888 &MW^DDDP]]MΝYx1***DFFo]FccKKK
߿ +++^|)x< JZFŵkݻwx{{EBBb19qDL"RVVǹy&yyy & 04ۙ?> - >5kBFFbV+b111HHH`hhH.]x)))8qooo\]]
wwwuƜ9s=z4aaalggǒ%K:t([jjjhllE$(**r)g <}*
}rm}Kn(,, ֮]KBBEEE GGG֮]Kaa! [r
MF^^ L6
sss1b3vXy%?~`kӧO{]LN|߾9Я]F{{;fÇsIF ͙3gDNNݻwGƍÇqttΝ;{nz*8;;g ؼy3HKK#!! ֭_~
OOOΞ=)NBMM
ddd8p ꤦCՕ =z0tP1005۷oKhh(K,ӧ.//g˖-}!)) .0a>vss 4|sҧO 뉎,ٿ?TTTpE ?~E 07n$&Lۛ!CP__/ 4Neoo/` j&L ~߷o_ɓ',YYYY233E) &N(N[[:::<} /_gΜQ$$$Xn 6mٳgӥK>~ȤI&==]#]vѭ[7jjjpttDWW>}Jrr2ׯB\__%{Q骪 ٙe˖DCCC abyM._~{W
ՑFEEŋ3p@ BZZ^ܹsPWWǕ+WSN\rEڵy˖-W^(**rE'11A{z{̛7Ǐ#%%Ş={x9TWWcccCFFoJA 'OǏׯ WԩS g̘1lڴ {{{K`Ĉ1g JKKhŋ ]H(9r{p@.]į_رc899͛aΜ9$$$еkW.\%7nb(9{,MMMXYY̙3qpp={r1444011ɓ ̥K={6;wϟ?ڲetBqq1%%%lڴ '''HNNlΝ;3k,LMM
mmm%)""B7oތ sҥKTWWݛSbff=/_̙3~Zcbb6l/_:unݺahhvח߿kט7o
qK~~>֤3ڵkL2 ;v ))XXX`mmϟYj,_7bhhS[[ӧׯ _`///v% .888Hll,s爉a}*/eee#//ٳgɓ' 9999-ZĶm9o///} ߾}~!%%%[6l` ˗/ѣ,\_~Q[[˲e#55 2}t011AFF 0blDFFRVVFee%dffr]߿?6m`(**ׯ_ 4{;O<ϏD,,,PSScܹTVV0?Nzz:GfPTT'YYY|ݻwH]9w DTT/.\@[[̚5bLMM۷oannϟE.ѣGcǎǏ ܸqB°VZJKKGZZ###>~pB ƍĄ{+йnbΜ9xzz|rv튦&477܌>2aԨQ,^X0پ};cʔ) 4 &MDEEe!
| N8 8q =ȑ#WV1# =z4444p~㩬$00Zo iӦ1n8.\Yz5vޞlll کS2j(K =cڵOt}a :ѣGc.]F]] /ݻ@ԏL6
yyymƯ_ 믿8zʼnPZZJaa!:::pa 9Buu5BLbb" ͍fb ?^M;0022ô333ZZZ߿?gϞptuuy) MMMڼy}.^Hyy9)))L6h}K]] ,YDTSRRX[[*2.]k.A[3 .ݻw\UUU
į_Wؙ:nmjjjo> :۷QSScʕF@@ O y!萖FAAw P\\̡CHHH`(++ׯ_2e
RRR 8pJ ?~,,AϞ=cʕ8::g ŋ)//_~9s///inn
Xz5:uJ(//СCr JJJx=555۷ٷo 7ofݺuݛÇGVX# DEEMMMjkkʕ+477@~ѣّLmm-***"}}>xhiiѥKpWUU֭[0vX>|*۳ePRRvlѢEqM6l@YY_|̌KLFFݻ}}}Ə Ohh(FFFՋ ~*4hӧ!!!X@ prrrmKBBҧO 9+`hhWTTīW߿?QQQHff&
,X/^瑔dJH___Z[[2e
'Oggg 8 999HKKS\\Lkk+VVVlڴ`Mׯ_;v,ׯ_,D9 IDATK4fΜƌCSS߿'22o"%%ży&//g"++K\\ k>~֭[QUUnݺ ^zSUUE^^ ?9sPXXȳgϘ1c-" f&O:Ǐ 3G.hhh O~X|X>JIIei˗/C
U}:RXXgϞҥKtܙKȅ x 1vI2d%%%XYY!%%Ekk04i >DZZ)))>})--QȧNJbbȬw ͖/_x())Izz:6lȑ#Gr1ZZZD&_KK xk
4K.ɇ {ܹs QOwss*:999 >|HYyyyonn v܉lܸQ>;hӦMʊ/_ìYgҥ477 -_766ׯ_E$Ԕz222%##',QQQxyyBTT>}ˋ .sjjj3g`ooϙ3g>}: .gϞ\p?(**)+KKKy b֭[XXXPZZСCѣG"ڑQRR"00CCCzMyy9&&&\kaccøqHNNܹs899q! >̗/_HNNf1999$%%9p ݻ ϟ?ٰa?f߾}i& N`` XZZOll,\p___sJ~Fɓ'\~+W0on+44||}} '""iii~Itt4 %G~~>ޢ؈.G eҤI ÇHHH&f҉^@ƍ:III<{ cccZ[[첼BN>˗/IOOluFss3Z,]Fll,x{{HSHKK3aZZZ5jeee477 ݯ_!&&ׯ_S[[?_ڵr.]51w\{GKK bkk ˖-SN2yd;4773~x֭[ƍ~:)))
&L`Сlٲ ~JFFR__ϩSPVVׯ ǰhiiDTTͨc ?4mۆ=ǎ 466sNʍ7x uuu466ׯ_gӦMHIIɳgϨb 6ڵ+ָ
[g 'OD[[7"##EWWIKKӓ#Gҹsgtɓ8YYY J\\ >fjjj1c s\\]G~.K,aܸq O[[?DǏGWWZIJJb4m4AР{ GԔ_~!%%Exx8 wpB:t(UUUҽ{wV\2X[[d̙CEEjjj RVVc|"##)))ԔvСC1{lZ[[8q"EEEqMh(**bkkKhh(܌&2|nܸ݊q\***1113EzjBCCٿ?QSSCss3ɉUVacc۷o3O>݆F*++Y~=?T_SSSqww۷ưahkkӧOsI2g?|6m}wGyy9Cppp 233ٵksΥwܹs*Kb]]]ƍٳWWW9y$;v젦{{{BCC3|k
/jHH}e۶makkȑ#e
ܼyF >ĉ166],{I~~>{ x-NNN ;v LMMݻw_?#%%źu$00I&켮.#F%%%DCC>}Gaa!7nӧbާO E|uɑ&MMMtܙx^ʶmȠpvv&66 ;bee#qqqT222())ݻw 4CCC***ŋR---͍/HYY 899ʞ={bҥrfƌ<{@tԩ唔ꊏDEEDZc5jXXX'^zG aĉfƦMÃiӦ~z) c``ĉD__yÉ'^KKO>ѯ_?a>|8tPSS[n-0l0^u ߿Oll,888ǏILLD[[_qF._VVV?| vJTT8Ԏ 9?~<䠬L^x 899qq d̞=[,/gʔ)ܻw}}}-ZرcQUU%..N0`ƌѣ3f Ǐ ͛77oDKKv fܸqGL¡CG X[[GHH"ebb XΝ;yfƏ Ǐ; >|&HNڶK.477K@@ &Mbܸq@CC_]777RSS (((0k,.]ѣE^ښo߾% c UUU8̈#(**5kф&o]v.,\PfÇ ͥ;G ܹs$%%1ʕ+qqqCޛFcC)s JFiPhT
WiU(uE$MT $\h Rf"X{~~<~|ޯ7GO`]qiS)++#99 6n͛IHHXOiiizIBBӦMCNNN@ٰa+WҥKrZZZ[[[
ϟ? |999hjjRYYݻwfɒ%t999\9sHMMeԩ
~MDD#F ~gggTUU?2dDDD0` y-sAII ???-ZD`` aoo/x3gԩSݻPPTT$//
>}BNNdfϞͱcǐFFFwޱe(--ŋtttpU xTw6 PWWWt̤o߾dddpuVZř3gPVVZqXx1ߔDss8+V`)..---Ο?*֭wlOOO=} *>yccc222uVb3i$}&81c n)ǏǏ 466 ddd[nȗ/_pvvŅSN{233OAA/^NTTUUU###CCCƸ;VXAVV8;;Guu5g&""Bb:O.ܺu7n~4446l >|A|HIIѣy _~ tuu رc<\:I*/_ !! ;8}z*ӓO2~x4441c;wѣGwLMM144dժUS]]-Ν;'5\pkg ߏ[
>'Oh" ٳghhh .h?~"̙3L2o߾q Ο?ϹsHJJbժU ?,^zŋ/cԩHIIN]]CLMM!??_ԪF̽Ϙ1mmmqL͜9;wEMM
}tڕ۷SVVYnq`gg''N$331cƠ466ҭ[7߿8t
߽{.XXXK @[[+WDJJ/^{7# @BBgggJJJ
peϟϻwXYYaff&:EEE > YYYxxxPTTDss3֨`bbBkk B]Vr7?ڿWPP
III9s&|4&MDxx~QUUEEEE ٴiϟ?իWHKKs
6l D,zzz 0 MMM)--eϞ=dff
GׯpǏϵm6ܘ;w.C̭[HMMeY OSS : QRtxbs---ƍBڞׯ_9r$222ܸq{tRϟO~5ksA $ ֭[(**wPUUϬ^z <Ȅ ܹs%iƔӽ{wlق1
_1c ŋٓ$ HPP8Ϙ1)S,7nDVV ;vθqpppp'RɉoryZ[[QTTdРAx)W&NH~~>阚Mnn.---lٲWWWY`L2͛7pq]FϞ=t=:k ˹|2 p }ʆ
͛7b VZ
Cmm-s444 СC9p -_˗/gϞ!--̀f1ɰi&!=t_fΟIQQ)jiiɱc0553qqqxyyѭ[7^x)SXv-rrr <} 7oܜqq5FAxx8tޝQFDxx8 ***~UUU-[xxx0` Q 9r$
"))E͝;wPQQ"""x
,Y333\)))A__o߾fݻwGGG
6#SN%44ٳgW "##̝; =zpN:šCx% 2SNqQ144d}0g F ɗ/_#llݺU/۩gȑS\\111Օ
IM>B 433c
G K4'Nȱc
% r300 '' lmmillݻ,Yv&O,&ˍ74i***888vZ044$66ggg;30l0444(--ٳgx{{O]ioogĉx{{ȷoXn ?f߾}2}tFA{{;ݻwgʔ)```
EYYmmm>| j۷nֲ` |رc
GGG>|ׯHKK'UUUDGGsmarssCMM3gNٳ';whkk#44Xۇ.mbbBLLH˙1|p
;vcӧDydرJTT-bѢE̘1kg7449s戒 a]tȈwމ(:fbpB!pss#44E燼|yyy
Yx0UEDD`ooׯ_qss
Q__ϙ3g033CMM.].fԈmmm066kkklBbbQRRB`` Ą'ORTT$^ݻwt)))y\ xb>|@TTJJJRQQAll, ,ɓ'իW&ӧOHII1j(TFAA?o߾1w\'//@Qb ښT婫CKK
.\(,Q:::L:sM)//gԩs)ȑ#0dddd011ARRƏ /c/^d̘1رccc |?777y#s!66 |}}իWwa988 P__/)gչf@SS :yyyϚ5khkk֭[|UVf(--ݻdXl'Of۶mBR JRR .$!!HOJJ
Wf̘1`LLLt999HJJCAA'&&eee2dz"// .ƍQVVf֭(**s
[layL:;w͛7qttdܹep-ZJ$+j---bìYصk ӓ#GrA"##)++YC&L D
:::deeCvv6]vO >Ą ?~rJ$zDFFBzz:W\A]]hy*G˗/xxxpY^ȑ#9}4zzzӯ_?233ShxzzdױO> 9rϓHEEHII N^^ ݻw^zl2z%]F˗₣#IIID@@ vvv<} z*'B-" ooo hkkCWW===PQQACC^~-R vݛ 6m˖-?ɓ 9d߾}IIIjkk =z_"@gƜ={V$|->} ̰b͚5$'' ŋ\ LPR9~8 ;SNQVVƘ1chiiAFFlͥ%%%V^-VVV =SSShnnÇL:i&~ݻw
ŋ,\wwwMFEEVB__@ >>t҅~OGGvvv 4iڊQBBiii ۷oy=...̟?lǃxG ܿ rrrӓ'OA =ߟ**++ KKKHII!EEEؐ?À'00KKK(++?@SS{s%022 '113f̳gϰcĉ,[v(..&//KKKy%k֬aΝHHH0ydnݺgǎ 4I&QUU#}gϞ "99III DK]]+Wŋ .(w˗())ɓ'LLL &Lŋutt###,YZ߿ wwwtuuեW"--Myy9EEEpB>}ȑ#IIICȋ[ZZ9s&ŢvZ a|///Ǝ +Ѐヴ4Vjkk9x yyy߿8\]]%!!AYbϟTLYeee}v9w K.ERREEE ?~̘1chllׯ1|poߎ9>}bԨQ :t7o2{l$$$ddd`llӧӧP! ;"
8s lܸ'O2zhZ|9oaذa<~5k[RSS#\8|ٱcÆ
#99r] K<:eIII
ƍɉOӧOgƍгgOPPP` > (//gٴRPP)FFFdddɷo8pQfggS&Ő/x%qqqK?/譭t
.]Ċ+(++xxxYCy3s5)))I pYVXAMM
ݺuCKK
ˍ7x/mmm{
vĄ$L.ڼzYfc;vH-_Ç(]vEFFϟ?舻;ݻߋfٹs'\t iiiQٴilFF,_\QRR"88G ѳgOGVV'''qpp sss\>Ό ?j8p ۶md-Z xzzeGBBulܸ˗/3j(DoT]]MXXׯ_СC444yG3}tJHH0tPKee%߿ׯ_ 111"''GDD_&%%(_7PPP@__J&Mb̙3̙3-[˗/5>> ###ٳg$%%|||8q"۷ogʕڵk!--MLL 888 jڵ+yyyX[[.:ݟiii,[Vlll?Ffhkkӭ[7O.]Ǐ _^߾}I&CXXܹs'N %%ETT%%%2l0x Yv`믿XjSLŋɏ ?شi1qDvڅ :t֯_: dٲe444P^^ׯ_ijj:nܸA||}?
!FFF!fddP__/Rޝ9
={hkk YfOAASNEII =zܿDZZt֍}q.\֭[166Ԕr qrr(
9toF!J-y9||| 433<)((@]]RMѣGx"---sifϞMll,FFFbggǹs簵eΝlٲEz ILLd XXXц
ĩ CͥCCC,,,5kH͛7EEE222011ӧO&l+g Mu& N>}DQQEEE ?J/_Ǐ РW^DGGm6~Jaa!8;;_;ɜ:uD.\'O022ɓ蠪DGG3w\1qzj
'--M`(,,ŋs\\\HLLBϟښ?ҧO """bȐ! >\jBCC
ddd $22Ç3fݻѣGˋ_~!C}uqv͞={R`O>P
at֍D
Ғׯ_`Ǐ 3gݺuݝOr}})/^{XXX
YYYhii L۶mCBB/_l2$$$X`̞=[gΜImm-fر$pttƍ_ RRRPTTPh=z4_~%00///Ξ=OpCNN ?#233IJJ
___\Bee%{!99lٿ?昘Ijj*x)...XXX*1BX~=;w$88_~}pss#::TƎ K[[ ?~d̘1lYLǣG>}ϟdffbee֭[ì@SSgFCCx&N ;7n ̙âEXt)͙3%K0zh#Gdҥ̛7\ ;ioo'&&ѣGfúu}6C۷osq
FGG[lǏ ̞=[Od(ՉXQQ***꒐Irr2Æ
Ց %%~;w5%88_䄌 {fرCX_zŨQ gϞݠ)cƌAIIm۶"P'Or-(..X[[iJ?%%sMMƝ;wqiͣG3b,r5wξ}ׯ_$%%/X`Ɍ36mCEJJ~b
ٙ;wGՐ#..ɓ'SSSÕ+W%++ y%%%$$$GSS^^^ߟǏ chhȩSXhvٓPUUeb<))۷o(,,3;wӧHII兏RZZ,+jjj455/0p\]]Xh =B]](F 111} B삂lmm100"ϤIׯ_X|5ӧOD44ܹÆ
pww deeի:u46mĹsBАw^222ҒBԘ?>HJJbnnNkk+%%%9s!C͛ٱc+V ""Bjˣɓ'0aO<ڵkStvINN6lわ؈
w料͛7-ژ.с 6l`$%%ѵkWrrr7 ń/lݺ#G6x]] nnn$&&beeŇ d`` 27oӧOHHH֭[W^﹢
ŋ(++ȯ_D cذas%lll(,,dĉ 9uֱ~BBB"ӧ^[namm̓իЏ7;wP^^#ZZZlB+hW^˗/m6tuu)--o߾aeehrvۛϳm6jkk"''Kرc9w ~z^~MVV:::cbbB@@ G ӧODGG /и&L₢""""___sLQ6n( Mk%<}BSS3 >|x455155 ` :D\\ ҴÇsvZzͨQg͚5ҽ{w(,,,$++ÇD||< bvժU/V\7BMHH7n@YY͛7{ݻ :Yf9^ ~-vjjj¡C:u*=z@BB ~ʇ :t(/_3fp%$%%qvvFQQooo֯_O\\ ?~o466ȷoߒȂ طo ...}iӦ &L 88SSSQL>b IDAT(Ը{.vׯ 444֬Y)(( --gϞaffܻwÇBYY' QQQ477cnnǏ9s9;;g tttcܸq1uT*++IJJb֭PWWG>}pqqa̛75k%&M@LL 999ٳgYt)~BII ---E:FA7p@N())ח02w ***:t(Kͪ^HHzzzٓ"q-ttt hkkٙbv
֯_ϠA6l899N3f nϟtޝgϢLbb"ϟ?G㎎-Z$jk֬ŋ/^̠A5j86 ?49ti3{lO.,+,˖-#66ݻwcffFYY}ABB[[[ܜ0uT ܽ{cjjʣG%""ׯd._̙3g6miiihhh ?fĈL<3fEvv6?$''G .]* L8::
'6m 2Rvڅ:gΜ9TVVʒ%K3f }ANNP ;k"h{.)))dgg3i$
ahh ёfN< ۷o'00 ϟϢE?>\r???\]]QUUEQQQG\VPPojBVVbcc),,~q5._,% 3x`IIIݻ|8߾}W^۷UUUϧYYYpwwɓ;w7oϟ"==5kPTT˗/?>Ϟ=#::
mۆ x{{3n8077̌ &??={bmmMqq1渺r6mڄiii\iiiؼy3 >0` '==}:deepB >|ڵkygϞ˗TUU!))ϟ?';;aˣHHH%wޥ"֬Y ?;;IIIM+**ԩSIMMҒ(}ˈ#ׯ_L81c B;e*++'**_~ѣGIMM!'O2p@3>>>zѣGi&jjjPRRB__DV\͛7 I%%%DJr̘1bF]^^ ===! 8p !! =777?ΠA֭?~`֬YdeeQVV4h{[4 p2c BBBXz5'N$88X mmmIOO_~ܾ}[QVVիW3e&NȤIPSS̛7yyy.]ѣGǁre ̙39s LKK 'O
뇶6"|rڰ֖ Nzz:RVV$:;-ZĎ ;022bʔ)chhHUU塨H@@ EEE̛7O
7n F
HJJ TJg966AqAYА_Μ9Cjj*PTTĹs𠭭
---QINN&''W鉼|ȇ xe˖Q[[Yp!JJJKbb"fSÜ8qÇg&L #GDAAA<7111,X gggé
&ē'OXv-K,a֭TUU˖- ---|,]CCC OUUtttclllHHH@RR7n233f̙jjj߿?t ߿Ϙ1c ۛ7ox< UUULLL!66B||<:::1zh ?~̗/_eՋ222֭| YYYΟ?ORR0 } Fr ͣ#6QL!B$PDHWyNy 4j Up5)TR2E$q~k^y}Z -v}?HsΔ1k,{LJ 'N{)..fС ?r9Ν;'SSLǏ \?舷7 >|`ڵŋϯ_իFFF' :Ddd$L0k1k,+++ɉ85jCe˖-#HW쨨@*bmmڵq' PRR 066gϞ_Ǐ3{lTUUN<ɤIf };
b1|pz*˖-А >|ӧ6ltЁǏ rJpuuرc={V7o Y3x`J\#""Ғo߾'8033DC022ӧO,]o߾3{vU1cb ȑ#X[[ccc#iΝ#99?NN:t(2223uTvEEE)))n:كڵ'Oxb6lѣٳg0rH6nHNN <@VVggg9rӧOG]]B={Y`X={6B@Evv6)))̛7|BBB8s L6
mmmmۆ&&M*֬Y9fff"++KII9Ϝ9Caa!jjjzD PSSWpdcɒ%\xOŴSNhjj?pEF ѣɴ㩮֖z $<< {{{s"ٔHssXٳsaii;ܾ} ;vs:t考
ԐC[[MMM ~ĉqqq)S0m4uЭ[7ػw/EEEbmmϟ?122,F%HRCAA/_о}{?.j1}ts:` FǏԩo߾ӧbccCˣo߾߿_С |ÇG>} ̙3Gh2228x hkk455IHH`ڴi?`jjJSS]ťkӧOE%++ ߧK.-٧O Ç 8p@gQWWgϞ<}T pd<<}:y._)|tĉ =z?ruv͚5kׯ_n[ѣBp|%a*RPP ,,߿SWWg˖-pm=z4 >cdeeILLdQ[[Kcc~^uuu cСbhhҥK{HZZ 8p@Φ`cc uuuDGGȰaϧG DHHK._~piZZZJ ͪUXdtgddpY.]+&MBFFqM0m۶ѣGe
<}7nݻ7k֬kײcә2e
III444stBjj*:::鑝͚5kx#G$ M6O}}=-bƌ1bN8P[[˂ 8z(}eʔ)\vM իWy .]b߾}"xyyԩSbܹTVVr=222:u*qqqtЁI&qiB^^}zj khh0uTHKKC]]qơٓRΞ=,MMMܻwm۶7ESSV***gϞ3|pƌáC{./^}ENN |k2qD+++DOSٙj ?Nmm- f :,011!99:{. tԉF8p ZZZbQ&..h:uDll,{ÃTW<==VUhh(SLA^^"""C '/111lڴC2ydݻ7eeedgg`~!{ƩSHJJ1ccx" lڴI\\~gϞGNDDeee477S__O'99x~EKK ~~~tؑ
xfff =zJJJ۷/Ѽ}9̂~
>|
_~o"HԩSPP@\\ ---<~*++)++Dh}Ɗ+`̙3???033cĉĈ3D|@MM
tؑPWWΝ;inn[n[999"""SNFyy9yyyTUUahh+7n`֬YH$aqU\\\PVVF*ܹhI333BCC111a۶m߿_ 322%44iӦG_ӧOijj͛7r5ټy3 Jd{Mvv6---L0={%nkHHHsӇH VXAnnk#ٳ'dffr%dee;;;ؾ};/^OD^^ III,Y%%%177baaӧOfԨQ$$$peLLLcǎ| ;v {nMD"LRSSĉ*|Y ===F__w MVV˳g """%++
}+bcc'o߾C_<|P(~Aǎ JhiiQVVFbb"TTTyfTF MRR[ne
$''3n8ڷoݻ7;wH =zѣG133͛(**%9z(_FGGG'{iiiٳh (,,$&&uuug̘1x ݻ'f fff > Tʎ ;
.iӦ}vZ[[ٱcyyy477vZ<==ѣ_"Ξ=ӦMcѢEz&ڵkGjj*lذd:v숟~ݻ7---ӽ{w_zɝ;wĎUUUדϟpYYf {9r }899 U^^O4*x W^%//ر#!Hˋ۷Ӯ];ddd=;;7o؞R\tuu1b| :0p@\BUU;wXYiwwwdee7nA-rrrakk˖-[pvv̌}biiIRR&L梤DAAbiiɤI011AEE%%%&Nӧ|2---8rrr۷ >nݺqE!(߿?7nd;w2 ?έ[֦ s"J9}4oAUA IDATU'NAZZ{ϟ?Ԥ#Gp)&L | =͛7ۗ߿ၾ>Ӈ ү_? 8鸺ի ,`bffƎ ;ѣܜ.\ŋի,\$V^Mrr2ǎ ۛ5kзo_rssECǏ | :c4i{ŋx{{7oژ-ZD>}~: J~:weƍ :t,"""|H])..ۛZnݺE~:t(X[[I]ٽ{7 >|`l{{{8w =ȑ#coo/666š5""??fA_n K,XT*eH$as3;G ANN7obnn-yyyL> f͚EΝ)--{tޝ
/_NZZWǏ SZ|,Xݻw1bX5rrrرc <`ajj*ಲ(** +---]va?@SSܿu놦X(((Ν;722sss&O +V`ƍZ
999a!J#Qnkk˗/"Hprr1i$4559r$_~eܹp% ?~̴iصkNNN"=pZZZGYY ?M[[(++sm ܹssΝCEE `ccûwX~=ZZZg fΜI\\ xzz
={ [nb} tܙe˖퍒ׯ_ׯdgg 1|p.]˗9t{=nnnfzz::::H$IOOYիWdzInݐߔ \Ϟ=144MMM9vzzzcccnܸAjj*$%%m???),,$11$n߾-֮]˸q8w > 0o<Ǝ ˉ'0iРA?< ___ >|("oۜ?@
%!!yCVV@
ySSS,YBXX
BOOOԵ&MDcc#+Wˋ/NXXyyyҷo_455e˖qIyϟ)//gѬ[^xA]] ]cذaԠ˗/144+++XH$)ollLJձj*n߾Mjj* >|$Qח]2` t邝 ۷o͛7899ѵkW
'/_dߘƌ#5+˖-իWQPP#G7o уN:pxyyqF ߿Yd ƍӓ+WPZZ =zϓP͙3PV^zkܾ}GGG ȸq8q"YYY'/Æ
GGGUVi&ݹqR[Ν;y=/2zhllleeenʓ'O֭(++cffFKK _~(ׯ_3uT0` }E,,,/EAA߿S^^NNNoߞW Çy53pƼ{ ?2h >|H}}=߿͛7L:G q}M \cccqqqѣwwwD[G Tq.]DQQ3gΰi&֦@IJJYE*re<}ѣGS]]Ϟ=c %Hhg***/^ !Ci& --
lllx5rrr$''ė/_D>800vډxpp0mmmѥKLLLH$8::Ç)..&88GGGܹCFFO<WWW7uVDmz+ի\vbRRR߿?˖-CSS7MKK ^^^ZJD 8p k!//ILLDVVɓ'chhȌ31co߾XXX0uT^zEnn.yyy(**Ejj`شիܺucǎ1yd5JJJ; 9w zgϞrJrrr+&L **JQTT KKKx왈LB^^ Rŋٳg9vfff<|Lz聻;]CAA###dee9}4|uuu0` SYYI[[!!!hjj2l0Ԉcʔ)1d|}}qwwɓt 9uخZPP@pp0 \]]qvvFOOׯ_SXX=?ɓ3dIJJ {{{KPPH ihh`ӦM۷3gP\\̋/fݺu ? 222|2o߾EWWWH7nȘ1cHKKcܸq\t =z?~<.]ܜo2p@FO>
UUU ޞUVモ"w;wPUU3(((0~x((( //jLMM100`ݺu:w̋/y gHR:w̸qذa0߽{ >0c BBB9s&MMMPRR@ǎ w $$$f' >| &&F #իNNN|?r)
)((@WWp444C"PVV`ȟ:uwމiMM
`ii"MVVs
)++ܜZZZ߿?йsg͛GZZʄ`bbBCC...1vX߿OϞ=ٶm`ehhhc[[IIIߟs)"p
100 ??;w0|5^bӇv 2KPRRիWx{{sAڱcPJp/_ .[[[pqqaСTTTʕ+ZDv* !~e˖q!/_7n@UUWWW֯_ݻEȠW^lܸSr%v͛7y8466r=0?=0|_ ztt46mBQQ]]]455EԩSձh" JKK ZZZIUUK.EAA*nʳgׯ0|kkk6oތǎ $MMMz͗/_a,Zhmm'''EA SSS
={6>>>\v#GAll,EEE\zEEEQPPݻ 9 >ğy``hR ԣGhmmE__/_2~xN<)w%rrrhkkӽ{wRSSgʕaddD"!<<"##7n ӦMŋ >|W^J <<<1b儅) ?&((H,n.]"%%" baaٳgٸq# PWWٳFPPƜ? gggϟO~hkkCOO+ <Tڢ+d*666$%%QVVʕ+E ݻwTWWӹsgn߾D"˗x͛7SWWGrr2b{6l%%%tjkk;wڵ9[nECC'Op%Ə rrrbx"""w ;v$44VXAff&!!!'11ٳg@ss3 "̡C8s cǎٙCB@@ nݢ>}Jpp0ƍ#>>^(444D_Oj3|p>~(۷iEE>}{ܾ}p~3f`Ν*ԭ[7H߿͢EPWWÇ«WD,!![[[<==innfу$tؑ!C H',,LWKJJx) ˗/3ydJJJhllwA_x1C #<Μ9!߿ CCCN:EJJ
?~`)**BAARdddpww
wȑ#pwޥ͛7 []] %%%bdd4hP~uڕ3fЩS'aÆ
cbbBSS̘1#G%W^%## w^>6m"44gggGׯhhhPWW
999hii1vX"""tG AEEmmm(,,߸!H}ߟbeҥqßaD"CRVV5EEE̘1J z,Y- >|fA?tϹpg|,\www 9T* 122TT @`` EEE)Slܸ\9z ϟ?_DƌC !%% D"`hhȾ}ؽ{7cƌAQQ'Op <3uT233111ׯ۶mcyL4 Μ9#c YYY$??KPRRBZZ
=z. ]vښu1{llll
"55MMMw>|chll̟͛?K.ѵkWOimmgϞDdd$SNeՔuVdee4̙3Gpp0ajjÇYx1#F`Ϟ= 0@8M
VVV5߿n:9uyxzz2|IMM%$$O~r
SL!&&
FӧO9w _f5J@tuu @ vo,/^˗/ƒĉYd cƌյk7*++qC G lݺw2{lquuEEE 0aO΅ ,^]r9ƌ#T .$!!ÇS[[KNN0sY[[cggGTT:::ۗWr-JKKy ߿g´4|pڵkGll,gϞ1FFFDcc#111l۶MlIwN>M\\ 555R^^E8s
ӹsgzMmm8|¤Igȑ萜Lyy9dee,>>>"//x1k֬~
www.\Ȉ#ر#ÇСC8q={
رc9pxc?/^L\\ >>>H$Ç;w*>{s9,,,Dŋ8;;PQQ!:::닛|!CJ߾}y9:::booOdd$ 0#Gbff֭[@D GWWWB =z
kEOOcbb"⌧N"44FT*%##}}}===ٺu+]tښjEeܜ\_.ֿ vq v˗/Z LMMx" ;vH0EE娤C1ewNTT={ܒ"N8p ,]DBzz:| /ٳg RRRիL>](Ǝ ˭[HMMɉ?EII ;wüy :`llL||}HKK CCC
ƙ3g% |ppp`ǎ Ckk+G ˗/XXX'Ϟ=888pIgkkk:u$,IxzzR]]ӧDYYN:ѿo =ÇE lf̘ VVV̚5 =zرc/X__CϟIHH` = cǒWUU?]
eee>LJJ(}ѻwo̙C144$33ݻcffFiiΜ9#F0n8!? $;;>}p}:wL\\ F
'''6l@aa! G e̘1444f.]8}(ٳ111hkkꊂDFFrYƏ /\%%%_ܼyeeeAGGT9DFFyfu&L@FF|{˗y9zzz ? B]] ۷G*r=Zn s%mmmݝVٶm[lё 9pBIn]b
1*))iӦ*}cǎE^^y摝H$^~Myy9 =bĈ`ii-)))PQQABB---{.\Ȇ
033#--߿xba!<<ŋ+QVVؘ`8z(ٜ>}EEE ;F]] 3qDֽ{2bFD"^zѥKCpp0JJJXÇ ` PXx1 ,'iӦq={Fpp0Ϟ=LGr غu+6l jkkҥ ?$66;wԄ3_R3f ={={`ddD^^ [0` p1~ͭ[͍m۶ʍ7x 2D+ Hkk+˗/Æ044ӓ(>}#~~~ :fFԩSuuu%%%Tʇ 044{bll̄ 2e
rrr~7
6 888dѣy %%%XCCCoN~毸X`A֬Y /_fܽ{rf͚E߾}s۷ktTUUs]EEXkii˸qسgaaahhhPUUECC?F^^ OOO:u?~zӧOQUUǸ!+++Rvnnn,ZSRRBmm-
555ӧOTUUɓ'РW^E = yyy %555 <0rH222HLLd۶mTVV2m4ˊ+}Jxx8'Ojx~~~3w\ ;FVVMMMDDD`dd5&L@VVuuu1SSSKVVDEEݻwZfONcc7ǏsqܹàAǏ K=$$D-F 2PVVFǎ ҧO x1<~>}..._ SSS.]Eݛ}}dlmm111SEEHII1m4~HII iii899qmvʜ9sXf
Fb|{s ,--4i $$$5rJV\ @UUJJJ (++SYY~?[eee7oRPP@SSޤQ__OLL ʼz۷oSSS2))) :tWWW
$ ׯgΝl߾EܹsKyfOIIfǎ \vM|;v,CeCN
"$$ ϟ϶m۸vOFCCdmkkcʔ)lڴ wwwRSS?~`D3}tnݺ~!C;666((( Wf
HJJһwoÇuC444pi\BLL ߿l2b˖-8;;ӧO lllpuuȑ#8::.GgΜ=&I}6&&&>}ϟ?Cg0k,̙SkÆ
0l0 TTTEEEEěXSS#F祬LEEvBNNEEpp0mmmdeeՕ ͛7 А8zݻwcccNHH邯EFFݻwG^^ ES)55ϟ?3k,QSS/_:u*ZZZܺu *++ }K.ESS;;;<==y <ߟ+VPVVF\\ YYYrIZ[[)))aԨQz+Wxb&$$, >| Nkk+$&&
PR^^ +W :tرcY` ,ח:prrb,^ =FTTFƆN:WKKߟ,͛C auM/^̗/_>}:...yfĄRܽ{'''***hjj{9x9-ZDxx:;;ӷo_v]XbgСC9s%%%jkkԤ ;Djj*rrrՉ&qZZ =ӧ|1c/1JLL V˗HII!##Cbb"Ƣbnnϟ?y NNN8::2ydΝ;۷ر#ΝÇ X݁ppp@WWҥ zӧ466C||<^^^ ´iΎ //ϑ#Gѣ"Z^^Nvv6 =SN\xWZʊS
իW111O>|3f`" uqϟ?
C]] OOObbbPPPDDD|r1vZ> <` ~.T֡CΝΝ; l2ڸt#G$00PԲL?][%'Oko.>_\\Lqq1l ҽ{wv̙3tJJJi
}`ggGHHׯ_Ύ 222166nݺDT元QQQ,X +++ NLL w˗4662|p&Oĉɓ<ӧchh(f}||4iMMM,_{φ
dyTTTɓ'lNʼys|rL,--p? >}9w {sαpBzeРV:w̃ػwk|A Sϟ?&wرcE fϞMjj*C !!!)]COON:̆
@WWW*++5jHIIqEիWtsssݻ FBBuVϒ%KXt)RYY TTTHOO &LMMquuG@ΝY~=MMML>Ǐ {Q>=%K $AAA\p<==IOOg͚5 ?~F 4...HIIq)~JPPakkKee%'NӧOkdeeٳ'O
'''v$%% ۑƍӧOメ!VVVرkkkqR :t(555b
HOOW^+++QVVShԸz*iee*ӇL{1TUUƱcx
SNEMMM{#Ϟ=[n̝;"tuu̙ѿ 8 ,?w"// cݺu899yfΝ۷[n9sF2duuuՋO>qQf͚1bׯ_gҤIxzz"%%Eyy9aaaHKK܌!Ϟ=eK
}DEEqaoٵk111̛7G Mzz: <@BBӱcGquwwo߾l۶Qs| ?JNeҤI(**̓'OcСTWWI&Gzꅢ" }G^^ NNNܼyuuu*++ikk#==}RRR* gϞ"͛p&^tz!Xr%~~~ 9rŋcooOee%]tAJJǏ h"6oތ?oԔ ;/_۷oÇGWW۷oFyy9---B}}=...ݻ/_бcG >|˗y߿'== :Qׯ9 :t:v숁tޝ
4Oll h >|Ȏ ;իqqqraf̘MPSScB~ wނCuu5c̘1
\ry) RDD_ P^^Nxx8zzz 1sÇi&^zի~:G Ąd'44s EPdɤ0b }Jjj*SNL>SN)222lڴdwM@^xAFF>>>`jjʶmܹۨs̚5 ؾ};}ח+Wn:HJJѣhjj"#//w"### NGUUU1S.cǎeĈ,]Yzg]STTTXbAAALHHHʕ+wʔ) 6 ?~Cnn.۶m\v8"""gϞ =z_ҵkWa
6o+++Ǐ#))III yyyx{{'%%ENkk+?D[[;;; rvvYfccr1:uرceUUULMM6l3f@WWٳg3ydlmm#&&x>nٲOOO =*4;w$55/RYY?;w$==Ǐcmm5 JSqqq1555tR>~ȵkx}!,,Xٰak֬#ʕ+())ŋ6lݺuŅJF ˗cҥXdvɘ1c:u*"N@^^q} =z4ݺuM ƍ3Yfg222x%DFF _ pssܹs444woqrssG aiiI dlݺyyy˅dܜ/Fff& ^^^^]]]TUUqtt܋/dggcddD~~:ÇY~z֬Y=
)9s044$""EQXXqssCGGb:wLVV'ND__ =zp)F Ǐ 9uG _~MMM
}st֍Khnn{{{ZZZpvvriƎ = ;vWWWRSS1b ?f 477#++˜9sx%UUU`bbq%W^舼 ,v۷oy);:s +W$::Z WXƍ9u?~`8::~~~"mddĬY0a3sLq"r
fff$''4gϞёBy EEE{,swwŅ'Obff [ne٘ceeEmm-&''+WR[[Ǐlܸ^x_Ǹ@>}hii`N:g "j~!!Vرc0X2 ;vdΜ9$''#))IUUTWW3tP6m$
TUUAjj*)))3߿ϲe8p uuu|ϟ?3` :"X :veeeիO<ƍ$&&
3={puueΝ,YtR 8@CCG\\\(((lڴ ۷o9~8gfƍ),,
ܹ3ǎ ŋptttϏZPPP`DDD0a***xjjjуϟ?CKK : =zW$%%CYY}}}nܸYHHHl ;r= 111!((8jkk;v,| N Dٳ={?>ӧO 9!C{3sLbbbDAA$~:jjjhiiqAEɓ'\~ ?VVVry444}kkڧaѧNR,,,ׯ(/y5LƎ KYY;|}}#..kkk$$$
eȐ!| ҥ4',,.]P]]-6 :tڵk7ٳgɥK=zNN< 7cǎ̞=$lmmBRRR jjjӓ˗3|p?"V |M̞]qƱh"뇁jjj2{lj絴v_x]`ll,\uuu2bΟ?OݹvH >>>x5^z%joϟ/ҩS''vxϞ=ijjܜPg̚5 _@\\=7nɓhii 3]v%;;~xbN7;wd"))̌$Ύfx-$%%_o>vAee%˗/gÆ
~%%%())ܜXNJ@@ [<}J
Dxx8rrr QVV͍ G ~z~?$-->}0h =zD||<}e$&&R__/]rrr.]">> cccѣG<{bOLL >>>477߿4i999~<== <<ߓƫWHKK#,,-[0eTUU}v;w# )Sp
{'gΜaӦMOQWW̌7 `aa ڵkS\\80` 8{,<}TIIIAMM
###ޞ|TTTcoիW|rrr8u---S6662h \]]ٶm.\`ʔ)\|߳[XX`nnNXX7n<Vtt4AAA())gD7,, WWWrrrFCCtttѣ666 >\JƌCFFw;wЭ[7v܉RRRΡѣ~0Ҹ~:ܺu RTTę3g(++c]ٳ!C0sL >̂ 8s :tmmmFׯw /Cݻw ">o< 9BII ۷ovnٳg166Ã8o ==)Sȷo߸x"W\B>} ΠAx%hjjҳgOϧUUUJKK100ΎG {ٽ{7} bz聗Blncbb A;w.111,] BMM
өkCddddǏ Օ 7n ٔQ]]555\z<}FNN{vv+ϟӓ[ngʢ[nG ĠJ}}='99???Ə 'Nf OOOV^* <@^^ ccc%TQRRݝ&FAMM
̚5{QPP@@@
ȑ#FZZ\Ə OUUyyy477#%% ڊ
"yڹsg^JII W^kz+W2eNMMM
>: ̺u߿?ر#ҴpmQTTdРAݛ߿M``:e{CR}hkkS\\,hkIIIHJJ{y~bС">{lԄY~ȑ 9QFƍH磥˗?999VZ>iii"qͽ{y&ϟŋL>sMn .\ X|9cʔ)DFFh":v( =zPYYǏ IHH@RRyyy&OweȐ!3i$Μ9GXQWW'--QF1yd EVVVܦ ŋ9<222ܺu 055%))
>}
'deequuENN :u*ݺu#99,--155L0(ټy3'OǏ hkkQڻw/vvv/ ;v } "jjjK|ܸq[N<,.\@mm-nnn\z/^ɱk˗/ʊ'5L8'O
thh(G eԩ|˗/BRRSNgϞ 8l>}*d%$&&ңG""">EEEDGG3bQswwGEEF/**===jkk),,|7ΩS;w. ;uuu"""8p ...,__~1h ?~,(ϧpaqtt :0~xvIss3ܺu7o %%E}}=L0777x:u" $a]L> %%%6l BINE圝ҥ :ubҤI ~HvЁx֬YCϞ=꿺˃/oYXXX>}ׯ2e
:uJ`i?}G { urrȑ#} 0I]xuֱf :'OÄÒ%KΝ;=}t6oLdd$b 5fOqq1 =֖cffF]]@ [k֮]˦M())ۂ~UK022Ύ'S"##ٰaS]]ȑ# ΎsW~
6>7c eС!!!AHH
D}}=s%;;III&::TN8A>}$::
6!IIIell̐!CpaaaлwoUݺu+RRR 4xܨZa,#44 :`ggԩSill$^|Iff&,^*>~۷ocٲe/jjj{8p _|o߾;wYYY\
'Nӷo_>,~^w&***<ϟOyy9߿lvi 7L!?a 555M:vvvXYY!%%`R\c2n8Μ9#0ܸq}777 M9l0찶6ؐ۷oٽ{7 fذa 6 {{{:tmHIIAOO6oL~~RSSի"!! |rJKKٴi]t<$$$&**7oްn:Ҹw yyy¯_hmm[nTuV|||xoǏ L>ӹt qMlllfÆ
ܹMMMY`())1g g֬Y ή]000}6ӦM\r&={&NVVVӵkWlق)))Z* =zw^444uJOOMMMAv={6t҅˗&hq >|@n݄eKQQk2{lXǣKii)
JJJ1}tt邦&,[ xl 033K.wHpuuƍDDD0rH ?FCCC:5449s&O|Hee%{조gK&NW\8˗"XYYqI.]yyyߞk֬&ƌCKK 555ܸq---:vH~x nbƍ$%% ϗ/_=z4Z/^PYYIAAglܸiӦ1|A'O2'NrJ +:w _|ĄyЀ HHH`gg6,]T4J8|0uuu())1n8RRRbϞ=3h r
߿?{h Cf2P.R4F[yu54B)Ѩm2F)?gZsiNy|}|| `1ٙNLLLy&\p!}3fp}/?}ġC777222{䠭M]] 9::;.]$\ۇ,s%$$W^S%115Q艗/_Nqq1=zE!##öm RUU)KBBvvv( K.rJLIKK ر&1;ijj";;&>~HQQXZZ>>>ҫW/RRR((($$$e9ݣMč꒗ÇIIIiiibccٷo (++3zhɓMII!CPRRرc{L
ڵkSUUźu{鑞۷od,,,DQQdVXshѢE :tyf y=---YFK.%11Yf7oވ\P aڵL:e˖SMNN\|6/CCC:::XYYq% θq㈌ܜ۷cccɓ6l fff
4F={ԩS.ӷo_"//Oxx8~~~ܹskkkXt),]/^PSS <<~͛7cffƧO077ԩSۋuBw/ϟ?Ϙ1cPPP ''pһr
?~$55""":ux!}6ނi&+WbŊK[.???&M9˗/g̙x{{AKK $&&
o߾G X $$$|ׯL0֬YիWcaa@^NѸ8ttt(..&88 djjjDׯQVVFMMFz)TvvvѣG9s Ҽ}{H~~>\x ;vPPP ř3g'DZZt$$$D6l ))#Fp
ttt2e
cǎ,Ųn|(,,,u555d
ƍ3f O|8vKϜ9#HҞ={MXXUUUա%899憼 ;vʑ#Gprr_* >\,.~'}
wJKK_biiIMM
?f̙HKKcaa9sHJJ͍/2j(ŤI矱X۷of~')++F$$$ۛHKKgϞfٽ{7MMM<|M6aoo/;;wy ɓ!/mkk+d{0
0bxTVV"##@}}=Çˋ#GiUwFbll,,[ =zPWWo߾yyy444xFFF"ELTT444؈Ҩ
Ycnn. = _ɓ'3m4444pww'99h۷/?~ٳ8;;w&L@dd$ .ȑ#>}'''PQQAAAkHHHBqq1̟?x֭[Gnn.
3zh}&4ƍCGGGtIII_ ̙ñcǀ3111ű`1c;wN\v?ty
{zѣ <ϳk.Ə OXXGII͛7ӷo_~bΝ{O>(**ҿjkk4iϞ= 9sv횈NNNʢ~~~$%%aaaG(//gÆ
۷[ɖ-[8p 888pQˊ+8<_fʔ)(Wq>!!!l߾Y|9ܹ555 ILLLJɓ'SXX$?~ܜ}aff&Kvvv8qbvZ"##5j ˗Ǐ ~z>LyyT%YUUEqq1 _ݼ_ɒ%K{. bҥg)**kVnݺ7ׯgĈ\v pQaǎ pBPUU;;;2339s&~͛7rrr/%%ŋCZZZReeeYn ݻ >%f $&&7뉈رc߿˗Drr2yyyB~~>aaap:::DS^^ fXt)aaaL2EEE&$$` 'OEݻGOOZz聾>[nVduuusiV^MFF&&&"Օz*:?V3||||bfؾ};nτ~زe NBOO5k //+EGG/FEEEPsrrNҤ$֭[ڵk?d֬Ycbb瑑ĉ$cEHH鸺"++K[[[n%((eee"""2e
">mǎ !//ϐ!C\|||ёNv-F'NĄϩ#11%%%mF^^ iiiܻw---yՋG"//OEE0qߟL RRRsDܸq .\@TTٓhR|2 tttw^ӧ$$$`hhH{{;1<쨨˗իy5Ņ͛77.^HNNcƌaǎ >;wpAw۶mHKKSWWGJJ
6l̜9XRRRPWW{]cE3ѭ4440|pԐ!11o߾!''3ZZZ8;;#''G}}=466***'552(//
@ٵkiii_O>1tP(--ޞӧӯ_?6nѣ4h >|_ LO2yd 0 ?~̝;wxHJJ'Xv-1118;;g^J`` '555clÇcРAxzzһwo˂ (((Nee%EEEb$--- mmm~͛ccmmȚ]x1{n ?ȑ#,[SN!))
/^$""$hmmAܼy%%%NvgϞǏ 0o<GZZr
666|kkk ?~UUUL8QP
Dzz: ///as999Lj#} /ڵ^zKHKKݻwQWWGAA^z`e˖g jjjAfbر(((/
R^^%ϟ{{{JJJ`ʔ)tvv2zh^zE{{; /
}eaaݻ1RRRcbbBaa!W\
puueժUlY,lll ?'O0n8TTT [nQYYɪU:u*W\O>ő2k%<<\t7nܠ yyyNJll,cƌ᧟~"?? ///yC^^ 899ѣG)++Jx222o߾XZZ2o<9r$봷4=z@UUYYY1OIIaoV^͓'ODI|ذa2tPpssݝ
6]]]dddpQx |Bp5ƌÚ5kX|9bq/))ə3gDh7o@AA ڄ;ؘϟ СCp+--/^pY ?
?h郾>"ml߾} >|MMMfϞMLL 'O6C@AA :;;;mmm,X_.pf͚ERRǏgƍakkKnn.2n8&L!C' "..999䋏GZZooo
)((Ғ˗###CDDxS WꢣIII߿+ ;v_ ?~ zŇ x hiiQWWLJ hoog ?~@AAKf͚&]]]l۶SRR"_%--- fرX[[3tP2d4551l0^~MKK :tΝHș9s,--QWWSү_?zIOOg֭lٲ#G7CFFo߾eΜ9LXX8;;SXX
fff|EqiV\IY` >ƍGFFFFF" رc2tPΜ9Á;;;ygΜh
D~~>...Q__͛74h rO>Q]]-vyyy9s[[[^|I~~>q,Y,۷^zaddD^^ ٳg|L֯_OJJ
8:: uuuakkP
rd~fѴr)֯_Occ#lݺӧOb
&L#^^^ ;k TFGG3{l455IIIȈ%N؈) D{pttCqssc͢EhkkcԨQF}}=XSNRRRTUU`QFDff& ...Ӈ?nԿ Lee%8;;z+9ɓ'QSScݨPTT%L]XܹCVV_~3댌 O~o߾EQQ Vb $--Skkk3>}Ks >|SSSf͚EXX;v`ݺu|={///زe b ߧSNaee% KKK9s deeQSS=GGG.\Ș1ce˖-ر۷~/_ۛٳgӻwooߎL:o߾xb1w8s 6m̜9YYt[n [NN&M"88L6l@rr2K< 6 Zkk+"FѣG444ׯ >ŋ8::"--Mdd$s
1^~fff2vX-[FWWg˖- ''2m4 ?'ODQQ(÷oߨ
5S[[Kxx8{eС<~mmmFAaa!~~~dggs뉉;(#BEESիWFVVVW
Dss3HKK!PZZիWijjBJJ3fPQQ7PVVFxx8۷o >L^^ SZZJcc`1aXlaff&1vȑ#!++wrqWWW000_~ԠHjj9UWWՕÇs= =z4 ?SNݻ˗E
X%%%]ƧODNzz:}Օ 0i$tuu7n pas&M"99;;;>}jjj]===x-{Lnرc믿-Аsabb2...hiiiHԔ(9viiitvv2dƏ ; cccJKKExFZZ}022ҥK %Еnb̙APP|&GEdd$yyy,[H >|H~~>lݺ}}}Ν;;۷h233ikkƆ3azIRRkwԩxBgϞ́TYYuuucĉ˗/9}4TWWcaa-gΜASS#GriO̙3qqq!>> ׯW?Β%KDallLZZ>}BBB VZE||<{ݻwhiiCpp0&&&?)[nϏNj"l2455)++CFFvnS\\:u
YYY&MCGGؽ{X
bdcc#aaa\|s1c |||pqqeLL 3f̠kkk\\\HMMܜp 4i"!!innٳg# ?~,^@ӣG
Ǐ())L͞={JϞ=={6EEE UVVFpp0+W"ŋxyy1w\7n b HHHpEjjj>|8>>>l#--MNN477133n;wXfд755QVVɓcѸCPPqqqÇ~:"thjj͛7(((رchii@ss3d֭l}!'''8{,()) [nC<ÇGCCϸq? G Ԕ0-Zի)..&(({Ō3CYYA!++KMM
"gϞ,X@ 8-[HMMESSccc:::PQQʊ$=} 8gggvڅm1tEEEDAWRR >~)֮]
UUU#--ͤIٳ,Y?̙3xzz{n{5 `̙ܹsYYYptt/2o<9{, |R铐 =SWW )))DGG3w\~ٳg n ={# ;VP)p^bΜ9Æ
7o } ۶m#??/2c ^ʽ{ӧO ,;v`֭Ğ={'++SgϞȑ#ݻ7?t矸 ''Gvv6߿S,dddx]t۷os1
8w nnnhlaa!L"SmƘ1c@EEo߾aee/5L8w&O:Ŝ9sx-fffxyysNNܻwuQSSCUU^BCCŋ3k,qDCCZ022bӦM|R*++t6|=/^ --Llllؾ};IIInݺ%LC]>'OٳEgvMD*۷oYf
ׯ'00&^|6l"|ѣG wprr2GKK jjje֬YsN~i$**JѣGSpc$̞=E._LYYݻWx(5jQQQFAA"iVOtt4Æ
Hnid\\ ._̈́Q\\L~~>TWWގ'NdѢEHKKʕ+̌+V0n8133ʕ+X[[s=L®]Xh#G={E||455@SS+WMPPhjj; 9nիW#ى!iiiTWW{yKUUFswuuc՝ ֭[EX\\ l۶H""";w1|pHNN&##5kPZZJWWzzz ? ;;;V\I{{;cƍ/ruLMM144ĉ"ŋI]] 3fܜYfavIII ?~dժUbpLMMQVVo߾߿ߣ#|cƌP~7(++CMMSSSäI͛7ƻwﰷgСL<``РA|EΟ?Ǐ $ƍ'uuu<}ag~ȑ#),,kג {ZZZ8qBBB_EgooOKK $$$dJJJ3f k%--Mt>ٳg{yCff&Cv3KCC ,`РAK̰ѣG466m6N>իW7o ~~~bggǥKBUU[[[갰`1'''4iOwyy9f͢cNjj*ׯԔ)S.]bҤI3s]HLL$88_2uTTT`ffƁ@OO'OFXX ܹs <\={&B Ξ=
4i7nDNNNϹ|2nnn<*444x W^#Gr444(** |}}8q":c///"##_
BMMj8<>>>XZZ/q444;QTTLJR"##]]]N:
6իWSVV&ܹsv `'OdժUtttIHH`Ȑ![6>}*
_,^???YMM|vcQ{Eii)NNN$(([[[ |
eee122Ȉ@nݺEFF_J999@AAmmm ¹sPVVTUUѷo_F MAA_~ 8HCChhh`mm̓x ,R!>>pvƍ#O2j(8^B`` :t ~'';;?aÆ &&&ѻwoHNNf]N)++̌s1|pLMMٰaC[[9sܸs899ajj*,¸3rH000ӓgϞqe>|555shnnw1m4&N(KKKy3fԝ;w@FFMMMTSSK.%--
mmm?N~~><~ cr]>}ʉ'Xt@AxzzÞ={kRZZ*bߣG~~whmmߋ سgs̡Kv177,߿` &0tPǏ wvDFFrJr%$$DWXAxx8&L z̙3?~^P$CCC|}}넆
V =mmmxyy1}t.\Huu5***HIILss3keĉbIcc#+V@UU۷իIHHի>ǒ'N`nn7o&>>| ? x)TUU.DZZZ#--222xzzra xb >|={ÃJVX!$ 8p {{{>~Ȯ]8q۷o۷oȑ#ٶm'Nd̙HJJ[ؿ?(**R\\6^kkk:::PVVf̙} ѣGiBEEw
WPSS q ^zz:7n~c˖-HJJ+ƌ#fikk {{{{ Q*6Z(-TBdKd Es KYBRZv^ZDgf {~S^a < Jyy9gfѢE466W =ʟ)f>cǎfN-nţGصkxyyE =!++K
˗/ʼy
wތ7pb믿UV{Yv-VBQQL~xaƻw ?T;͛PXXȣG`ڵ:l0prr 4443gRRRу3k֬9
}Μ9[ ,--#005k͙ fbѢE8::;rHW^}XrQQ>}WTTqGG#99B<==Yt)WѣG2` Xn uuu̞=ݻw7oܹs 8۷oS]]III8q+~Wbcc0aWz'eee$$$`bbBnnٳ*~Yx1 ooo
Ǐ 3g&&&444ȩSx DEE.ݢeee(,,_~444&HII~"""Ddǎ Z8АLEBCCfrss ccc2dXTvC HHH@JJD,A IDAT ӧ;GSS/_Żwē_YY͛7Fll,˗/5krEzAFF888JYYCE__`DLPGG}Mcc#>>>X3f`ll<,_z "##ooo͍҄ \]]oyÇ:t(撖Fgg'8;;E+W8p ʓ'OPSS~ښ\ߏ}6$$$PPP`ȑ̛7O۞0vX"##eeeܹsx{{/gfϞ)ǎ L0sӧcܹHIIQYYɖ-[xׯ_Ç <}}}1(++cѢEB` =zĜ9sÃÇى7)))#]/s1b
$wʢØ1ctϮ.&Mڵk144dL0EEEvMyJ? y.>ԯ7n`jjJrr2ZZZ|*|}}quuEUU***x7n$##[[[144$,,}с=O>n߾k֬(**bbb"f6u oFLL QQQ >"444زe gϞEKK OOOx Ν}}}fΜɭ[HLLHKK 0c7"##Yl?fڴi :0>}:---3zh}-666aeeEYYc777~ʺuz*K.eLJJ
\|jrss)..LJ'ODFFpCv[͛G9y$/_(iӦEee%$%%$@Kzzz-/_$44===jjjXl666\r|FEYYHIMM
gϞG |
TTT8}47ofرN3rHnݺŭ[pssMdd$eU__Ϙ1cprrݝ'O Ι3g3f K,ϟS0QVVիWJWW xs-9y$ϟQTTdHHH`mmMdd$̟?,qcӦM > gggG覊._ OOO1˗?PQQALL Æ
>}$`XYYQQQ!QQQTWW'
HNNF]]-[xbMFkk]<\\\());nTn\Ds ;pvv >p %%% 2rٸq#cʕHKKFAA---dddܹsٿ?DFFb``.\`TTT0uT 8rtttPPP`ӦM #G7oސ ;v~~~1BF!: w!--
EEEȑ#RZZJaa!jjjxxx@BBCEII۷ocooOKK ,[6oѣE)+++tuuyƽ{ $$$SSS{=;wDJJÇcnn/Ņe˖7Yh888p =z"'OёqƑ/TXZZb`` ꄄIw .~zꅟ 7oޤ ;vJxx8qqq 9wwwoF I = Ą6n܈&ݻ===d,[۷o.$...7ZuttD>}6ܻwmmmXn TUUիWƆׯ_s$%%QSScĈ~zO)PVVFWW&Lۛ۷o3yd (ل!Jy9O>ŋ ;vLĄ?|@kk 7^rVqvv,\8
SRRBbb"ϧݻwGyy^h,YBNN/_J^?KAAͣ_~˗/燻;DGGSWWǟ8::beež}c 28
DFFzݻmdeeQ]]%'NРUV@BBvvv[?")))73sL
Xr%۷oW^Kd+**pwwGNN8p B$d ?~իcǎe3w\.\ {XS>}sgZ[[
gggQm^POcʒȹϜ9SZZJvv6ddd`ccCAAoĄ={&ZRRR|IBCCijjb y(())ӧOYx1rgrwwŅٿ? &66#G̋/ذaW^%000I'..iii/_.ܣ;v`mɱqFܹÏ ?3k%,,6LMM}6[HIIAZZøqPSS{>>>HIIf~H=V^MUU?ߟ>̨Q8qh
Gjj`<w P7 lСܼy6y;cƌVɓ144Ǐ qttݻ455accCFF[(v͛9s 'Nd
룭Ǐ a)SCeҤIXZZ2m4$%%QQQyyyy]UVVbhh={VXA~~x,Z:;;aboo>}% sUU =HHHm6ӧi&֯_O@@ ӧOgҤIKVVкIIIɓ'155e 2 ?~ٲe uuu<}]]]IJJBSSpTUUٶmǏ'""~annNpp0ƍvBBBpuu%%%%%%233` V^- wNXŁQUUgϞɼy}o߾̞=[ȟ̙3Ei } Ǐ ' @@9s VVV"}3dv)))L4I4 rrr,Zo߾1m4!*AAAw$~7oݻwӯ_?rrr055Xpss ___.\-yyyѻwo .q|f͚ڵߓŭ[ LÇ Lee%˖-c߾}:iii </^ &L0hiiǏAvv6---899Cee%8::@~PUUlz___;geeEmm-+V}}}-ZD^^jEEE|kl|>}PSScXiiiCΎS[[ׯ_qQ===ϟOhh(o۳l2FAWW7nܠ'OPQQ3jjj\x ;v~ՙ8q"|y1߿'??J)((tvvĉ5k1l0ƌ#߿ ț7o;Ch" >|H߾}y% >D__e˖ ϟ?_~aco."}%%%(++ .rxx8.nAyy9;vE~fϞͳgե[nL<ŋӷo_444x9|<2e
{% RSS@WWLLL EѣWȑ#]]]#%%Evv6]CBBiӦtRINN^%=z4{a2---| nܸoزe . }}},,,R|JKKdxzz"--˗ijjbb;sL<==پ};9998;;DCC6l`ٓ͛7rssErܸqƢ
b<}#Gŏ ? EKKvqvv@ LK 9Bii) >---lllHKK?S PPP,,,Ą<֬Yquueƍ$&&ݻwٲe *|鴷S]]:G ɉK.all{~{QQQAJJ
ӧOGSS7opA6o o///lllHOOGVV>}B`` G 庺:dee @
c#GPQQϞ=uܹsKFYYYXl999ә4iC\Kbb"())Emm` &xb\]]Hߟ3tP$%%`Ȑ!BrmmƦM[ (**Ν;};v,'N@[[
Yd 899兽쪫xbΝKQQ/&99Tkk/_2m4>~(/s},,,j>~پ};'N@MMM ֯_ϨQ&11rRSSYf
[l˗/,^""".cǓ̱cǨ@RRWWW***FGGlD̰{!dΝKNNpUhmmɉ 0sLΞ=Kff&W\ayѣv={D^^|۷XXX ))ɂ hnnfÆ
ܹS***077ӧOX[[3` vͿ+"viiiRx"?d]RYYIAAނZ&^tuu܌ G gII ӧO N>;}ѣIhh(|G gݺu37779r$999|MfxxxLZZ鄅KFF&&& //Ϙ1c***lڴ kkkt W9ϝ;"]#88={NWWk֬֘?˵k8qn`L8Ǐ ȠA000`ѢEP\\ٳ' >|uuu"##IMMeҥ믜?W{ =ÇK~Hii)eeeDEE1ydyΞ=sssTTTp߾}#== a e͚5gË/(((֖UV PRR"((K2bE@UUP Hvv6>}}}}lllqVVVB -2e
]]]tvvbnnNYY `ժUҥKqssgϞ\~]v1n8jjj{.FFF8;; Ԁ߿?ͨr
Ξ=Khh(Ç ^x'jjj ս+ٷo L66N<177W^r F /˖-cС <߿cff&]]]ۗ)S0m4233۷/_&88ϟyyytttg3ÇSDŽ De6~x,,,$%%Ξ= nb
ɓ'Mrr2#))I<<<8y$s-Ο?ONN/^(& PRRbܹx{{sAN<Ç100 555`l۶ =zp!V^Mmm-&&&odffRPP$^^^>}Zؙ6mڄ$bKZZZ&00ŋ˗ݻՋ#FPZZJpp0FO>1j(F )^waݺu|Jeʔ)֒ƍy1Cزe\p߿ƍQ `PNN333ؼy3QQQ 8p
?~,III#//uuu j*ܹèQ߿?}İa i)www91b :(PSSCVVcr <?dq)!p'NdРAիWJNJuu5-b߾}L2ϟ3g F"_ɑ>
:::_ѣajj*{Xd oAVVlBuu57 ꒛ˤI/D^^K.QVVFSS^^^DGGESSڢ˓'Oѣ,_\0!())#cccΜ9xIKK#!!ALL #..H455>}:#FQϟ?́EWWH\]]y26l444؈)B@@ ;v`̘1PUUESSEEE2|ZZZDQx cƌΎ={R\\,d\~2 >,>o˗/zjB[[+W2| ŋL0!C0o}bΝĠLUUϟ'##www숏',,[2l0cڵBADoڴ KKKΞ=+fX[[b
v655ȑ#ݛ߿pBoλwPSS#--
yyy6lofB²~ZZZطo -(Ǐ XZZ憎
XXXqFVXALL &&& [[[.\ gϞ顣ׯ'N -0h 6mիW"66LLLHLL$((///:::cŊ3ӧlݺHzz:ӧOٸq#.]bٲe|<Ϝ9Ê+7n ߾}Çݻw144RҰښ 6lbggǁ8p /---dffG&L'OPQQaĉB [[[ ҥKUUUMFzz:'Nlڴ$ٰa'O֭[DEE"߾}cӦMOAA~~~ 0Ǐ 2yyyĄf~eƍ TBNN L{{;_{{{ϐ!Cf\~__beeѣGy|6111͍wRVV
$.. P__+vbСTWW### TTT닡!/ܻwӧOw^֬YC||<^^^2a,,,DzԔ' =*2o<x>}D|||<+V
)))Kee%ٜ={]]]zٳϏ͛7sI :ڵk >L^^Xv+iM6ԩS R[[˯СCYp!ACC+58~?<|V ;FFF_ ={ӱ˗|ӧOx[XXC={rilBgg',XQFQRRٳY`hiiQTTDHH
cҕ!CA@@ 9990~x<<<ѣ3f̠UVˎ ;8vkԩStttsV\صhjj$n...lڴ8zIII (**2bf̘ҥK133bLZZ۷o'>>'O$|bqE]] [455
uy/++ ---IBBOlܸ(9qo߾grA.ŋ=~6'm۶FBCC100`W
ƢEX|9MMMltTTT(++#www/^̬Y022BJJ3gqFAuttkbll۶m#11Ǐ Lpp0)))ѯ_?z쉯/222|I 999ʋ/ٳ'"//ϦMܹ,Xw`
ܹSڻZ)))ܾ}eeeǏ ?# 3gΠIpp0wѣ()) ћ"skpuu ƍ7"$$ӧOS|||_ R(**ljjj7o < 221c`dd_|ŋo1` 144䯿by\rB^^q )>>- >|`ݺu7oް~zߙ9s&477Ɏ ;ʕ+BVV111ʕ+IOOg۶mӇ}QQQ)f"--zɞ={(//}}}TTT ^_~SN-FFFXXX._ >|G X[[SRRB~~>ү_?{dzgXp0KJJ2i$_ɓ7n ؠٰaHIIpB|@]]]^۱FRRvݻw100 ++ ())--- 444`oo7:::,]]]$$$;⊈֖۷oTFFW&66ggg iii}:IIIܹs )))LMM9t>} .`ffF`` GRR===^zrrr|}1|3$$[2k, OHH`ժUأG>}Ȳwvv2i$^|Iӓ ?j={2m4V^M{{;>>>HHH
_}}=aaaDGG܌7(**"%%ѣG'ϟ'::EEE
ܹsՋH)))ѷo_ƍ'xwٳg;wSo>044:NJvv6 dƌ ѠAޞ IWWϟgx{{s 8p ,NuYF'NHٹs'vvv͛;w.JJJX5k0tPjjjhii7UVKuu5xzz"!! jjjիW۷/[lZZZ8u.\n}MM
ljBٳgq)aŊ0p@HLLDNN~znݺEMMׯYx CnݺL>vYJ֮]ˣG6l::: 27o2rH/ĉikk-ڏ ?҂XXX 'O)))>|@^^Hxu[®\ٳQPP ;;uuuJKK9v▾n:2e
6l{nK 屳9 pף? _soܸ ';;tR^3NG 3
$"w磡ׯ_BOOpTTT0''9sPZZ*xyy}vqvvF__ KKK>|WUỤG~:/]]]1p@,--BCC>}Ν;)//B d6lV0-Zĉ)..,
Ǐۗ'OB`` QQQڊD '''|BmmЛuuu·o߰M욚x=waҥXXX`iiɢEPVVsss]&xǏ I~+W
EFF>}`bbBXXG alݺGGG
cժUHJJڊ|===Ar\f
RRRTWW Xڄ 3gW\ԩSRXXXXX|r kkk^~477#ZZZ044ĉQTT ɘRZZʚ5kx ڵSNN>}000ל?,ڰU W^hkkSQQYd /^FHN[ne[~)1ݙ!C %%E>}ׯ nnnHHH{n ?NCޛc}ۻLQf B(TViPͣe!QZQQQ>>{yC 0͛73yd
p,\333~wEu˖-DFF' =ʻw8w x{{3rH^~-cƌAOOO0û⣦Cjj*ׯ_g ##êU MӧeeeRQQ!⊖ cccZ[[ŰVSS ͎ ;2e
DGGSQQI(,,͛L6
___***`t
}}}#D:t(:::>}CCC>400@MMN^~My
7aGzz:yyy8::ϟ@Ņf)**ߟv033CFFɓ'ZZZ122B^^K.!))ɰaèW^[:;;֭[>>\r%%%dddؼy3+Vؽ{7XXXJJJ<|+++-[&h^bXYY1j(g.[n%44,iii!>>-[PTTĩS:t(ܻwKÅ %,,L0ƍlZZZbooOTTaaaAPP7oٙ2F )DmmmĠ NNNMMM˞={FE۷oijjbĉ 6LeddHNN%KK^^ $%%1~xy֭#>>Fllls=zEEEqQƍGbb"&&&,Xlڴ"nܸO066ڵkۗR011!''/_`bb"2~"!!lmmy >|@AACCCm&ϟҒ a͚5<~I&1yd|}}y
\|Y@
qss#22<~%TuFnn.舜 ^SYYYrXYYakkK||< XYYO ___KP@J+SNԩS ϢE(..O> h={.]Djj* `رݻ#G2sL֭[!ښ} 47nܠ3g2UUUŽ{HLL]]]x...ЧO $$$={6ZZZRPPKJJANN(**
qӷo_w2/&## ?~пz쉖>>>;;;._,ĉdggƚ5kFGG0n8F Ϗ\ΝKMM
DGG BBB&lmm*]]]ϵkptt<ѣG#''ǭ[ $$]v)L_a``9s;o&88X /^HqqQF$Ϟ=ӓg2x`в-mgg;0arrrkܸqe˖(DRRRDGG@AA3gDKKw;*++ٰaW\AQQQ ~ .dܹTWWsy.^ȓ'O5jUUUƕ+Wf
6 ^*%ܼyS 6:t(?~FBBB˘`mmMgg'+Wdذa ))#?~={n%=z6Ͱ&,Yŋ)))G3K.G2qD\Bmm-ܻw;w0o<^x9~8JJJ\x[ PTTDJJ
^^^̘1/_K,YBQQZZZµkal;;;N>Mzz ӦM#FٳaҤI,_ ooo<|0;vёy1$$$0r5Ο?ϧOXbrrrdggSZZ;hhhPTTĦM͍>~jkk ggghhh 33yQTTD[[!!!$&&r
?>bmmMDD \vϟsa˗/b%ӧOѣtvvȋ/8u111cmm-fffhii1l0$''Ç̝; 9r$ ?~$::F&M111j KYY6mbٲeRSS}Ǐhii1x`^x s۷o֒6kիWܼy___:;;qrrBFFӧO3uTRRR
eѢE}5k`cc#"w֮]KMM
ttt,_~Ջ/xfee۷9]T-ZĆ
#FFFӭ[7{x{{tR{ƍ033gϞ듙ɕ+WDPR9 8wG7n ..yyy}Fvv6+VM6|[%<$''f6oׯe̘12bXEE|vŷo,Ǐ 888Cz쉡![lalٲ,,,066f =ݤIޞr,XݻrAEEE|---MKKx^UU쑛K^^ FFF$$$p%u8}4.]ƍhii1~xZZZgƌ^4/_ʕ+ٻw/7n`ժU"|
ظq#.\ 0իWNYYaaa[NEVVÇ7\|@HKKٙsQUU,߿B$ݻs
^~-={
y&0fEoذa7XQFYYPa"! deeq***JHRRIIIGEEQQQ
9999\\\ݻ7zzzZ}FNNa[[[STTDdd%K`eeEAAyyyHJJ[f͚Ō3;+V۷DOOO ^u놺:\vMkjj8{ b-[L yҧO LMMߗǏ,^777 >oƛ7oHMMEKKK x?>QQQ M}}=ZZZcaa+L0RaDDDAVV!!!lذYYYq_qZ[[Νc"0еCɡL܌V222$&&R^^ٷo |_(++@}}=gϦm۶ISSSN,Y{{{طo Dee% 8piӦall{"99Y+ ?ΣG077Nhh(wEZZ'R__Oxx8RRR1i$q4qDJJJ8r'NڵkIIIAZZZܺk :tHw.,brrr())1tPNҥKAWW}ҳgOO+# zݩ_EZ:wܡkkk
pssCAAiiirrrPQQӌ1###E{,33S.ڈ[dk-,,XjnbddDEEnnn(++CGGMMMɮ]&L --
KKKfΜɺu;v,ƍ333̙#ȅeeeȐ+
TVVrejjj0` \p___022hWbcc~:7n`߾}xzzr xmoo۷oL>tQUUeܹĈRAA!!!!?~`Νlذ a d] =zv8s
BaÆ!)) FFF ?ݻ3h پ};'O}}}l۶(ԩS;v,ܹs9999t~DDD"Uxx83f`ܹ. {Á3f SDR;::011ANN =ʫW}Ȑ!Lkk+DEEaii>/_DOOTUU111!::cҷo_퉈`ɬ\ptt$55[[[ژ?>
ȠɬYXz5rrrܻw%K(:...xzz
ʻwPTTUx466r!V^ͳghjjBBBCCCjkkBZUU3f@AA8|5{Srrr>|8jjjc~Hxx8&L(WNYY˗/̌ÇǏ ? 鉍
ٳwRWW ?N0;ݛdA֭mmmH1 6l&)) A!''3Hyy9AAAx{{3c Dx\]]9z(
>>>,^mmm)**6WWW߿/~;vҥKL: =z ###bbb9s�]]]pJII1rH0444 LCCeee[MMM 83z*Gf˖-_¾}8y$ք pAjkkg[ʐBEExQϏ+VsaCI IDATuttƆ֭[Gvv]vg2k,mFjj >nݺ1h 455իb ۷o߿?)))ڵ/_E@@ 7n$$$mmmBBBVtC===(((`Μ9tttK]] |)SDnneee < ++ŋ9~RRRے˛7oĄcǎ!##CHHΝcٲe}!CvZ ݻٱc+V{Yf
ŧOHKKݻwS`bb۷o3f eee| rrrرckhh6%%% 4 >ży #22֬Y#4ZZZ ^L\\ >ό5 ?~puۑׯ_TUU1i$"##lÇ:uJnBUUU4~Gٱcٳ֬YIMMBEѷo_'~\m۶!''Ǖ+Wʕ+TUUuVfϞٳqsscL8UVmEWWWIJJBZZiӦ1|nݺݻwsaƎ +TUUj*
سg " ϟ?ޞ/
3رjV\Itt4<{ 777ٳO={6SL\ӧOc``@bb"L2dMׯ_R$7._Lcc#0k,xʤs-|}}8p <~ٲe AAA_ >Zu놎G aŊcjj3={%?2uTmFkk+o߾ENNm۶Q__Ϟ={ӧ#F477deeٺu+rrr1g &O̗/_طo ]ѣGKnJDD/_;w2i$y% $88OOO֭[=z ..L,,,ڵk3o}x>>>҅Uӷo_x!#GӧO̚5={ Yj ?fСDDD //aaa~IxȡO0 ĀÇ$&&RUUUUUtޝj,--IJJёG(^^^ڵcR^^ &L@ZZ((("d777> 6mmmeȑ|CCCUMMM`V\qww'??BF%_~%&&aܹHJJܼy#GYQXX(ӧOo1` PSS CCC$%%E R@QQM6NHHBq5233ߙ1cǎ UKĀشiݻwgɒ%!%%ł aŊ~***ظq#'OɉG ammŋ
F|ڿ?_~Ր aΜ9tvvgY V^Ν;qqq!88J,--cΝY777JJJ:u*ƍYYYu =zHKKϟ?h)}_~ϗ/_~HJJ
>>>hkkcddį_زe ())ӉʊӧOvs ٷo
hs碮ϟŋpm >,`}xyy@~~>_ Ouu5;wd$%%Q]]h!Wnܸdee%ϟQF"!!yHMM e144DZZN >L =8y$3h fϞ-]]l yyyTUUȠ'rhkkgϞ퍬,2f
s7n >|9994442d'OFKK iiitm~o߾f
ĵk>|8߾}'rmnܸ|+++2e
'88kq)af211Ғ[nQ[[K[[tttPRR.~~~1sLfƍXZZˋ/GBBcNJĩSחѣGb
|#G 8fz )MMM TLǏ _^ ,--U)--%K ''GBBpE}Jmm-<{nݺKQQ/BCC%%%a ##TE|BMYYoƆ9s(t#G[nbrYjkkQUULj8q"qqqdeeO>č7=z4AAAL>G 1g qQ'&&bkkδi(,,DCCCDYl IIITTTPVVF =9r$K.ޞ_~EFF#G?$::ZP\Bnn.>>>c }vΜ9(++sm֬YCtt4Æ
ٳghjjƃ3n8$%%innGԺ]]]M^^ jjjߟNOqq1cҤILYPSS
:sE&MĠAPSS#))ՕH >Lbb"ݻwĉ| KKKpvvHtٶm'Nr9uNsssrssٷo qqq,Y{{.\rrrӇ|@cc#eeebLnn.8::;}ʕ+)))aL>[n1zh455 $008EZZ 1/?> < ZZZhllɉ͛7~ HKKё/ To+WDBBB B{E||< 9t^~.RTTDuu5%%%bll̠Aرc?~'OԩStޝϟ? )..f ٢Iֆ+L:hΜ9#j < ŋs Laa[oL~~>;8::رcinn&11悾g Ĕ[[[N}HMMe ;vUVx=ׯ_'..NFA{{;"D@@ Jjj*111X[[i&3g曓夤
EIIIX>L{{;(((0tPaa'N>-d
`ѢEpYN>͋/^iӦ!))'Odȑbǝ?f\t< ߟtBBBeܸqKϟb!C O>ٱ`xv ߶w닾>STTDCCTVVbkk;䠠Xr :GUSS
B8fddDSScƌԩSL6
{{{pttyٳgYj.]'N?&F3]t֖"6mڄRRR2j(
PTT$$$Vn߾ɓ'9w ɓall̛7oرc#../_0d߿<Ϟ=KHH>>>3d-[Htڕs};7 ?7o2g n߾-999¯_GCCC@ۙ2e
'N 999N:ԩS:tM]] F˗|Ǐ E9y$O>e,ZM61i$"""ӧOv@MM
ݺu
=zDJJ =zmmmÀ eee>~nbѢEdz|ry&&& :tX&MĥKСCӵkWaDuB~~>dggcffFjj*dee ֭[|X"""5j]ׯ_;:;;y DMMMYh֭#++ٳgw^,--ihhgϞbbb /%%% }ښo2{lddd8<۷{s
hmmҥK%+Whiia֬Y듕ŋٳDDD*4ZZZ$''SSSèQHJJBKK|䨪ǏR\\ɓ' G]]]X ϨaccYYYȾ}hooGBBtuuiii!;;KKKɉ+Wン3Bd DPPEEE =HQ
ՕÇEHHۗ]R]]1s o"''GII \rիW#!!Aȑ#رCboo/ͻwfiUU#Gܸq7oTWWS[[˺uسgH?2zh"""ׯ_+666LgϞ 90bbbضmZZZ =Z81ssss5JXqtt%%%OIIR BBBFGG &MĢEׯRQQIݺǔ˗/ӭ[7
ϧ455ڵ+UUU_ݻw&p%ۿaUUU7p1`"7ndϞ=eBQOO]vQXXȍ7|E~e˖1o̟?ݻwرc%iň#Ǐ yfnȑ#CKK* DGGG1qZ[[IHH ={(leֲ|r^~Mrr2iiiHHH7W2sL
$hjjRVV&cllŋv*PWW\H ~ 8991yd>|8pY&NH>}
Xp!ᔗ [(-- 0tFϱӧ|333
EEEy 2V"\z5o߾V:::شi/^`ڵIMM
߿gʕܸqZZZҥK,%%%#))I||<)))DFF X|9E] >>гgOmFFFÇgڴi :tZ6n(S srr2 DDD z
{{{&O̠A
ىRRRBaa!
"11KKKlmmEdOGGGȘݻ7kcΜ9$''ʏ ?
W"##Cxx8'NDCCl&N?ѣGgСCիb{e:;;7n TWWNii) :iiiVSS֭[lذA
quu%::"x"rM! ;v,zzz\///222 9??ׯ_pBN8exܺuׯ_sA'88TPUUEII x .xbÇ PSS 8zʢHt҅K??9}PVVƄ Р@dSPP X%cǎrqsscUWWGvv6555 waȐ!ˆ
ppp`]477#ҥ SNF|}}ښ ضm
Aff&NYY555ӧϟ';;$
Fmm-,Y+++/_ns9/_ξ}Ғ$##fΜ)O>Օ/2sLbbb#ӧOK.\ ---OTTaaaL:)))hmm֖ZTUUY|9 ۳rJ8}4(++ANNׯg ȑ#fdeeѿ\\\XnlG\\ &&&DGGpww(߭Llmm=z4~~~`dd$:7oϘCQQرC82äRRR011اObcc/_Yfq-}ˊ+ӧ#766wҥ ̟?_r ;Fdd$'Od儆ezŚ5kXtȣwڕ .NII W͛74555|ߓD߾}ҥ ǎ cRPP@FF>}ŋTVVԩS_SSv =JXX...BMCujС|rcӦMX[[-ƍߟCRYY*ƍ#''k2rH˗/lٲCgz˗/qvvfQUUŮ]"::Z ɉnחZ~=HHHN]SSSN}D =rwժU 8sq~JMM
FFFB%K ++YYYra<<<0a m62d >smr=!_Y~=eeej*>}cƌaӦM̜9nݺ ΦMx!EEE=.\@EEE$$$pppƆ+W?`ff&܉affۗ/˝;wǏGKK{cnn>fʔ)ddd`jj&wK,XΦ
___hhhɓdgg7VXoߨ%''E၌ qqqL4
8s Ǐ '00nIFFg3K^^`҃LJ͛7d
doȐ! ''MHH۷oaÆ +D .""Bj\\\믿HNNFOO &pa]Ɔ
ݻXYYaaaׯٰa7ǒq1h <bђGpp0(++ͷoPPPǂn:?ΰaø~:'O˜9s_~QVVFUUgϞgϞ;w͛7,
BUUɉZ ?~+,,,}n: ~Ν; ///lmm'6mԔ4ƍǂ Ipss͛7|q[dѢEcll6)))7|)SH@k:uJ,_~ͣGTNo߾ܾ}
ZFIII.]&((bZZZx9笠ƍ'$F"66 222سg䐕Ŋ+IϓIOO uuu}555[nq;wȡC1c;v͛7())ahhȶmё#G`ccÑ#GwzHA_~b\^^ ...ܼyV^xzz~z.]JSSxyy&5,Z{Lmm-HKKAUUӧO'<<ϟl2$$$Çܿ SSSzATTsAy_FVV7o`ooOmm-xիWh":;;9}4 <F-[Ƶkװ$55U`[ZZPWW8̙C\\< 8p#GCNNk֬aرL8rrrhhh\|UUU$22555F Mqq1 ?~dL}:466իW ܹsbhh4ؠDZZĬY())ȑ#ⶦvvv͢EhiiAUU/^@rr`WVVSTUU;v,$''caaA~`ٲe*?QXXʕ+Yz5FFFx{{ СCQPPݻwzz^AGGG{>hjjGnn.|
ՕrTTTܒ-[0c Y~=уǏ Fpp0III0rHRSSٻw/,] DUYYs2a.]Ǐ v|}} aooOtt48::IIIaҥHIIѣG100 ..]vѣGY|9˖-&336 `ݺu?Я_?y5 03g ?(..F]] . --͟Izz:_|sssx@ ?~ݻw?dވ#Xf
Y8eĉbeeEss3
tvvsN4 Tbcc&##^zw^TTTx/^___vP͟? n߾͒%K()) kkk'++ 6mMMM`ddļy6uEEEΞ=KGGmmm(**2j(k{CLMM>|87n@II 777`ʕXZZr-mƑ#G$%%Ή'022"77]]] ;/ܻwOA_x!`ooOssx=y)));RWW FFFSB7o ***hiisNillqwbccCqppgϞܾ}]bffɓ'QPP)S͛7yϟ?g˖-"%%ESS:::l2tuuSSS<==DFF<䈍ݝI&!%%űcx lٲM6̎ ;ׯX[[ӿ>}Dqq1B 쌡!aaaioo'**
$%%yzMHHŋ#''SN477į_ʢt${F__ ɓ'b$''CzzhEy???(**"11nݺe۷/ѸpHMMeÆ
pu EGG瓐'(((B\\ {ˋ/R__Ouu-ZHȸ+**055ڵk[.]ŋXZZ100ӓtzAKK (((p
z% ֭CSSSd{G MXXKNN R s={$%%GSS `iiIYY>>>r-̙h#'mmmݻ133#''wr)|}}EI ???w֭[ ӧO,^ggg={Fjj*~~~|zRSS?>xxx:::C۷rrrt钘sQs9s&cǎҒ%KPWWG]] 'Nŋ| ooox)ĉF>}x syh3FsŋƩSѣ鄄wػw/]tggg{.Çg֭̚5bttt5k[ÇGdd$Æ
իWѵkWHEE'Nŋ2e
߿ǏuVpssCVV===BBBdTWW3{lAJJ ?R\\ nnn#'''@U ;v '''Ν;Ǚ3g022BZZ 6m߿gȑ pEEk֬ݻӭ[7y0͛7+W %%%ԍYzzz }Wn߾9t҅srrr044 Nʈ#044D^^'ONmm-/gϞDDDн{wʐǏ [__ϐ!CΎѣGdee)))aر-%%%|IKKcɒ%q!8Yz5eee|OOOLLLصk:::|j:;;DNN< ۛ͛71̜9`F͛{.ܾ}PUU)))̙{ f̘%K(,,D_~`
JJJ8q5̝;&(((ƍKbb"[nNU IDATVpO~cbb uI 9}4 ///^|)f殮HKKSPP@\\ ӧOڵkxyy+騩!## ?/^) >dÆ
b9}t6l NY^6lI`˝;w@[[___D555~~~HJJRRRB]] \p???Off&7oޤG $%%̙3b$%%8{,%"mmm\t+V`eeŕ+WK'N`ff&Ŀttt`ooIHHL:F1G 9sFK{HKKb_εkpA{/طo ZZZhhhKqwwGVVGGGLJJ"--Ç"ߧk 0k,ׯ_^
ڵk
EBB 155%//e˖ ECC]VwՔ3(+++ѣoÇvZ v{a͚5DFF2k,<<<7o _fڴib*nNTTϟG]]6:;;?:t(cƌ!))B̙3122˗ZDJJJطo 2{BCC۷oGsvv455իWIOOì[N=vJee%[eeeBBB1c/_dddpI~WXv- >G,9y$Vb֢رcYlaaaܹsWBcc#111 0rrssߟ0|||8rnnnߟpDZZOjjH3{lN:@ߵkݻwGOO}}}ƌCNNhii,XYYBUU]v%%%\mFll,̞=={䄡!ۋMcc#OΚ5kPTT͍$ Xb'O >"%tttmDDddd`cc#,CeҤI 4#G{{-ɓIIIaРA ?~RUPP7oW
|}}ILLDUUU>/^Lxx8uuu,Xf\\\DII 1 aժU(++ĦMؿ?HKKj*˩ ?rIbbbprrbΜ9DGGӿ֮]˱chooGIIo[URRҒN6n(}>} =^TTͣ[nDEEQ]](qaٳg 8p?h>:::ߟ~vZ$%%rrr1b tǏ͛7UFF`"%%Eii)/^`ԩ}Vشi߾}#,,sBss3>} >InPP/^@BBǏo_cc#466. 8:: O^زe gϞ)))t=z4>>>رCH iiiavTVV2|
F~~>:::xxxyѣ)((ڵk 2}RRR1tPLMMXEEV ?"/_߿fbbbׯ 'ptt$33 g ##Dk777aڴibѣ &&
6ƤIHMMDj}}}:;;ikkCOO)Sׯ8q"/*** ? Lbb"iii ؿ`$%%~N>M^^ ޤuVn!IKKccc#W\xooox5'222Xd cƌʕ+,Z}}} = >ɓ'!++:_ ̙3ĉHKKӣG9|0Νcĉ3~x͑#Gػw/HKKg͛EEEl۶;wRWWlY OΏ ?>|8TVVRWWǁcȐ!YݻSZZʘ1cׯ_Չ*,Y/?)))&N(v_~%33ÇE\\ ~~~XZZ婼￤eZ[[ihhƞ۷tRlllDcm466tR߿
>>>BpATUU7۷cmm9~8 , ,,Ǐ ؈9//b8rHkdĈڊӧOGNN >dy9#::/^```..J{{;pMw/,[L@133ŋ(111|Cm6imm%00[[[CSS888'D]}
888p%KEEIIIHJJraܹ͛7!l7ΝÃ1ceZZq߿>}P^^O}Hrr2є2i$ի666$&&^JPP9sGB@@ 'OLJ &oJÇʊiӦqe 1c$''}v >)))BdHKK Ǐ G__۷oSLA]]ѣG'Z[[QPP֭[())1w\\ׯ4iMMM8::CRR 9 $88߿s9}VTT_~\p2Ν;Ghh(#F֭[{ټy3'OdƍHHH7\]] ͛ 0&
100aaa萜LVVeee8::
EEEܽ{ϟƍkpp0666ݛNʬY8\uu5?f|~-,˾};v,[lΎ ϟ?STTĚ5k믿;v,hii -#F@dd?6VX!{le;v`رӇڵk
[[[VX
c̙,[ EEE,Y³gϐ 555BBB;G zxx8~"44O>Q^^???ϟϹs022̙3ٳGnܸ fΝ; $%%e6mtuu 3blmmӧOcooШ,//
!&&'$$ hhh`֬YQXXȘ1cXn FBVV'OٳdԨQGػw/f .пPUǓ˗2 >d˃
o߾>}͛'d퉍%77͛7s
u]zMLL iiisaƎ /^
C =bƌzj*++IJJbΜ9477ɷoHJJwܿ '۶mc₿? lܸwww`;%66M6Kf̘>ۓNbҥ/FDDT\\\?cddD]] qqqXXX~l"|5Fw ,777Ғϟ?gttt3f tuu
ۅ̙37ʚPQQa%%%
]s
[$(-- //OBBNll,+Wbrrr*dy eeep9˙>}:7nΎӧzj\_ӧBNN1cп---;w999,,,ؾ};ꈋMtt4---rE֭['CHII MMM}?c !ACC>>>qi.]*?y6mΞ=Ktt43gdΜ9̜9999LMM9qℰHR<<<(,,dҤIիW?{ E DNN5557]EoݺC1qD ~HJJ
RRRݛgϞ1m4~;3f`ԩŸqXv-ӧO :::QXX(,N*#ZZZ6lʌ5 .p=֭[NJ+:t(---XYYqi֙QTT̝;tկ_?
9u7odggn:Ξ=ҥK :::>}:#F`kkק III9~8^"33dee2e
~@ ?~ׯ 2{{{[q҄DݝL~Muu5SNP3 ?'ORVVƥKPRR
xxx+ 8s \t 8~8uuǔ/^0aRRRذa!!! 0w'@і/_Nxx8AAAx{{穬DSS;;;lllr
ĠEGGgϦ/_`bb ϧo߾#AcaaA\\ 8;;c+G aԩ !!!}vlmmޞ6v8XXXֆǏ ڞMMM̟? ]]]6oL]] xyyQYYɺuPUUM`{`aa& 4зo_Mll,***b
u[BB7oqqQddd={6jjj\v/bbb"l}?ܹ3f5 ***;wk b갰0KJYY۶mرc ;$LLL%44UVQTTڤ ?r- =ȑ#"!!q!&&ƥKIBO")##/_& ɓѣ̘1a
S^^>>>xzz
BMO>=L0Aa"M^ghkkEvv6w玲D 'ՔrU ; o߾[XJJJhkk )TWW#%%EWW[nӼ~SYYINNeee<Xlll2dɜ:uF >|Hgg'bccCMM
ϟ3O{lڴǏ ݻy&vvv\|߿κu먯ɓ' ;.4x`tuusHJJ
`___={FRRw l}???$%%qss ]&($믿hii!555DGG~^~锗 E#GpQ :Ď ;ϟ̜9;;;vC'>> QUU hlll#!!7;wBll,>>>9 IDAT!..NPP`bbBiip#۷otww3w\phh(ؘF,--QPP ##
ƍǛ7om۶ѫW/Ν9Sp{jiiRRR$&&rMܹCEFF۷#**Jkk+/^`Ӈ
^x ͿsB¤ kkkΟ?Ozz߭[ؽ{7eee_2|}}ŋi&222غu+ՋH}ď ?x̘1%%%2e
yyyQ\\ yyyyl۶_)UgϞ͋/077߿/_(KJJgEDD8zxtssz}&x 7ѣGֆ1Obb"n
y ٔXv-Ǐ gժU>}ZXvyxx !!AGGl۶Mx- ݝ ^~ڵkB^^^pjhhȑ#Аӧ3h >~Hhhq~:lܸS
oK!zhddEEE ;v qqqo;v8gǎ qF/^'N >逻wRRR{$%%QRRѣQRRbժUlذA0GUUUvZL ͣ'"''Dž &(('OEkii~zJJJtL4K.;3444 NNNذqF R9۷o(++Ζ-[6mjjjbggǖ-[N,--6NNNJuu5FFFֆ$3gn_~999:::cٳBBB 25k+6mڄ SLlذP,,,b+lTTTعs0vqqAMM
uuu ?~̔)S9r$rE,Y"YpEn$ .d۶mhhh<mFLL \x#G2rHtuuyܸq(Ϟ=cȐ!tuu1o<6lQeժU466r!͛G~Z
|OAKK/
f777dddȑ#}~ׯyM $$ݻw'sEFFFH<{~ =5773~x9w gΜaܻw:_mWOm]\r
?/̟?W^w =ׯ__WJJ:z(ښPOŋYzH477Gii)AAA 9;w`gg Օ
aÆ1rHgܼyiii1b 8|0555 9gggzꅸ8iiii&
5j222lܸQ_Bbb" ڵ ONjj0?>}:DFFRQQǎ #;;wwwۅlUUPVVFSS 3l0qrr"))˗/3oǏ GII,CII %//3f .\ P8)//g˖-p숉Ȉϟ?#//O\\ iiid >|(FFF|JƌCCC#!!aÄŷ) DEE7F Izz:fff3f jjjܾ}` < sss&MDuu5)))Npp0UUUqFVX"
-LΞ= 1}tTTTDCCZ*++vuaʕP]]ͮ]Vjj* 7nPRR¡C8p ))),_WR\\ܹs8q"'N焆«WdӦMÇIт &33EEE8zy AEECtt4ܽ{---F M\\ NNN$$$`aaAZZ֭[122bɸQ]]M]]P?aРA_`jD 9"lcbbpqqmmmK6l {1DGG#!!Acc#O><˗/ߟ}bjj ?J jhh+,Y~ ...T077bbb2vvv899ѷo_!}AQRR7o$!!ݻw yV ĉ0a߿ʕ+m'qF
ظq#]]]ߟ$Y|뱠6 ///,--
$bzJT߿'!!A }=2
|]peRRRtttqF ^^x߿,7mDe\x777^J^PQQڵk ۷ٲe ϧ6m =bҤI,\'O?9NBNNn-[&h#""YxЍ5^z gbjjJpp0iii 9III틮./^ؠ| 9s&"%%-˗155%11/äȑ#Yd yyy͛eݺuܹgggV^+V֖.\ȧOpqqAOOLQWWGYYGGGhmmϟ?s 8kkkkRRRLJ!C`ffFbb" { ֯_ʕ+1cWfժU@ ۶mʕ+ܻwQQQ133Ғv ?~Lee0Μ9y%wϏ\ 'O$&&F0űtRBBBX|91j ?N^OOOW!##(š FYYƌCQQMMMTWWSYY#O>E\\իWSRR-̳߿/ٳgXZZ*zzz,\UUU >|Hyy9ׯ_glݺ8 Δ)SذaFFF <KKK.^1^BMM
CCCf͚caaAHHSYY響! +Ve&gggxW^EZZc?0a)** UUU"??ׯ_ceeٳY`COOR[[+_ 8 Sbcc̝;s郪*O>EWWPQQ!-_|˹v >̌cbddD{{;߿%K7oraDDD5k˖-###CɥK hnn:MSWWWg 8|۩ !!ׯsmjjjeyHIIQ\\ԩS۷QZZ1 >wwwJKK122gߟL/_NAA%znzzzg055Ϗl HAA<=55ddd1c|oooڸpCxxx ##Cxx8Ç',, kkky&666̜9hll$++R*++ikkCZZm۶ajjJ߾}aÆ
twwO&O9x G !55@9,ڭ\v
qqqx߿ajkk)*AeeevPؿ?툉ၔΝcѢEѻwo233!99s!**yyyL87o0yd222R
/gΜImm FII UUUyСCXYYQSSÇQVVf =b$X,X N<&nnnhkk#4oop1V\ɗ/_aL>iӦ&O<ʊK
݂.֯_Ϟ={?OeiŊ[hϙ3o
HJJƍϟ?7n ***1B(/*\ѣ^^CCaÆ1j(}6nÃJ c |j$
<777部(ǏΝ;lܸW^7V^3<|5kM~~>cǎ'N`iiɾ}FYYvjjj055EAAÇGKK w222B3Օ0!chh \rٳg۷ILLҒ ?S ((( |}}eD~~> >x&33zŢEueeeB9+++|HQQM~)ԃLKKcРAHHH &&Ν; DTT
Yv-'Oׯ={D033ޞ3n8 ?~ߧ7o3\ b̙HKK'֯_"|?C߽{ & ++KPPmmm_hhhk.Xr%QQQL89s`eeEYYD||<ݘcdaa9 >|@__ CCC.^Ν;gʒΰaHOOCnnnJ[[#Fv ldzm6pqqALLr͂ سg999yFbzyyh"ZZZݻsI100(PWWpiiiTUU{nĉPQQ ` UVoHJJB[[ׯ_ckk˩Sׯ_ڵ#Fʳgزe ݣ\L4N >|Hvv6$&&y勀Tׯ۷o
7t ̘8q"W<44͛7cnn"AAA\p-[KZZڵ ^z+PZZ
۷DDD˶mۄ]F||<~~~|
GGG]P*..KKK =L0r6mDNN111mL628p dgg燄uuu ?BcJKK177'!!y CZZ֬Y=O>%))+Vɓ'y-)))I& ) y5ŋX[[xbttt3ۗ7n0uTx灾sNN8 {m۶s4i˖-#66)S fJJJ0aC̙30p@ddd(,,$??/_1 ?777>~H]] $%%JSS }6֭[lذgϞ ,]TXJ}{zj$%%0` """ ₲@JJ
mmmqss[hZZZ
ZCR]]MII 䄿?444`iiX
GUUٻw/sΥDLLLHIIA\\,--qwwҒ{ ٳg ^ HGG>}wwwlllb̘1XZZ$%% '''AԄ1---CZ[[),,ڵCѫW/* 쐕BYYYӧOCVV%%% ~:hkk kkk^~-,X:ܹeeeʈ &&x zzz455 JOQRRBzz: ~ K!LDDSL!99Y ȲeˈfB IJJٳɳg%%%˄ طo @YYA}vӧO 4ooo***HIIǏ HKKErr2PQQ/_yH[[uuuHKKӧO ܹCuu5r)/^L˨cnnNNNzzzܾ}t4556miiiܿ.\#lYh,GDDpƏ ݻEEE1220="<~A~~>Fr
DHH]]]ӧO4i3gddgg ٳ+d֭ 8mmmjkk;ׯCCC|}}*LMM)**b̘18::bmmM\\ &&&'bӦM`rss (=K$ cyaѢES__sqoߎ!ׯ_!C **Jll,xyy K666 ȼStttx
555EQQ(++edee;o!99wAQm ǿ `̰Iq)
B
5( Z idN: 3BIalJE.b
h) Rr? Yϟ؝RseOTTxxxP[[VeY;w0j( iӦde(Cʕ+),,oaΜ9︸(;2ϟO?īg}ƙ3gQ9}4111dggcggG[[ 6Z
F ;vNFF/Ç?777RRRhii*.]ڵk}6aaaFvIKK f''', o&22RyCnn.G ~
СC9}4+V{r9u2
ry =z_|;;;j5TTT(W^^^ ͛7n }:-_~A*
ڔ6k$&&OXX7o棏>h4R())ˋѣG+jmll(//ޞ@Z[[yٽ{7ׯ_'++#G2}teQCgOJx
1bnnnTUU)- :D^^Zɉ =Jzz:&:BBBXt)۷o'99cǎ)njRo_ NAAjR˫OC$ SUU?o5]$[.$I,$IVBn AO'Ob4:u* lmf'MDHHeee}:W}}=AAA8::reg[b0W2<ʣrEEEBHH/^^.xt6XƑ#G'MH*bbbB۷o)"##Cdee !1cX,v$f͚%߿ lϟsB'tfqMpBQZZ*t-1m4.L&ظqcxУrUUU !(++3gB\B<:B{bƌB'M^̙3J qvvVZBp (((S "&&F׳
> !BeI_ekkwܹsL<A~~~dxs1hRu sY_'=l?F[[9qqq ]VCY?Mjkk$$$f\]]LJ˗h:;W3&%%`5nʲe˺ {dA DllrVjmmeРA]+PfjA0\x* ?~\p~VZe:;3j
\`0 dA+Wk."""vW[&\z!fY׳ !pqq:k:
rH^Jss3gϞeرJ>ޠjT :::!C={6z JEff}!C Nc 8;;wy֖+V0eO\(ߓ$I /T IENDB` glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/ 0000755 0001750 0001750 00000000000 13752535025 022614 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_cube_v0.glu 0000644 0001750 0001750 00000024145 13502206677 026021 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsIDQsIDIsIDUpLCB9ICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAAoAAAAAAAAACwAAAAAAAAAMAAAAAAAAAA0AAAAAAAAADgAAAAAAAAAPAAAAAAAAABAAAAAAAAAAEQAAAAAAAAASAAAAAAAAABMAAAAAAAAAFAAAAAAAAAAVAAAAAAAAABYAAAAAAAAAFwAAAAAAAAAYAAAAAAAAABkAAAAAAAAAGgAAAAAAAAAbAAAAAAAAABwAAAAAAAAAHQAAAAAAAAAeAAAAAAAAAB8AAAAAAAAAIAAAAAAAAAAhAAAAAAAAACIAAAAAAAAAIwAAAAAAAAAkAAAAAAAAACUAAAAAAAAAJgAAAAAAAAAnAAAAAAAAACgAAAAAAAAAKQAAAAAAAAAqAAAAAAAAACsAAAAAAAAALAAAAAAAAAAtAAAAAAAAAC4AAAAAAAAALwAAAAAAAAAwAAAAAAAAADEAAAAAAAAAMgAAAAAAAAAzAAAAAAAAADQAAAAAAAAANQAAAAAAAAA2AAAAAAAAADcAAAAAAAAAOAAAAAAAAAA5AAAAAAAAADoAAAAAAAAAOwAAAAAAAAA8AAAAAAAAAD0AAAAAAAAAPgAAAAAAAAA/AAAAAAAAAEAAAAAAAAAAQQAAAAAAAABCAAAAAAAAAEMAAAAAAAAARAAAAAAAAABFAAAAAAAAAEYAAAAAAAAARwAAAAAAAABIAAAAAAAAAEkAAAAAAAAASgAAAAAAAABLAAAAAAAAAEwAAAAAAAAATQAAAAAAAABOAAAAAAAAAE8AAAAAAAAAUAAAAAAAAABRAAAAAAAAAFIAAAAAAAAAUwAAAAAAAABUAAAAAAAAAFUAAAAAAAAAVgAAAAAAAABXAAAAAAAAAFgAAAAAAAAAWQAAAAAAAABaAAAAAAAAAFsAAAAAAAAAXAAAAAAAAABdAAAAAAAAAF4AAAAAAAAAXwAAAAAAAABgAAAAAAAAAGEAAAAAAAAAYgAAAAAAAABjAAAAAAAAAGQAAAAAAAAAZQAAAAAAAABmAAAAAAAAAGcAAAAAAAAAaAAAAAAAAABpAAAAAAAAAGoAAAAAAAAAawAAAAAAAABsAAAAAAAAAG0AAAAAAAAAbgAAAAAAAABvAAAAAAAAAHAAAAAAAAAAcQAAAAAAAAByAAAAAAAAAHMAAAAAAAAAdAAAAAAAAAB1AAAAAAAAAHYAAAAAAAAAdwAAAAAAAAA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 2,
"pix2world": true,
"to": [
"World 2"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 2,
"pix2world": false,
"to": [
"Pixel Axis 2"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 3,
"pix2world": true,
"to": [
"World 3"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 3,
"pix2world": false,
"to": [
"Pixel Axis 3"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_5": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0"
]
},
"CoordinateComponentLink_6": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": false
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 3,
"world": false
},
"CoordinateComponent_3": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_4": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"CoordinateComponent_5": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": true
},
"CoordinateComponent_6": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 3,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DS9Normalize": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": 100,
"clip_lo": 0,
"contrast": 1.0,
"stretch": "linear",
"vmax": null,
"vmin": null
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"array_0",
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3",
"World 0",
"World 1",
"World 2",
"World 3"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"CoordinateComponent_3",
"CoordinateComponent_4",
"CoordinateComponent_5",
"CoordinateComponent_6"
],
"data": [
"array"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6"
],
"subset_group_count": 0
},
"ImageWidget": {
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"layer": "array",
"norm": "DS9Normalize",
"visible": true,
"zorder": 1
}
],
"pos": [
0,
0
],
"properties": {
"attribute": "array_0",
"batt": null,
"data": "array",
"gatt": null,
"ratt": null,
"rgb_mode": false,
"rgb_viz": [
true,
true,
true
],
"slice": [
2,
"y",
"x",
1
]
},
"session": "Session",
"size": [
731,
529
]
},
"Pixel Axis 0": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0"
},
"Pixel Axis 1": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1"
},
"Pixel Axis 2": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 2,
"hidden": true,
"label": "Pixel Axis 2"
},
"Pixel Axis 3": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 3,
"hidden": true,
"label": "Pixel Axis 3"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"World 2": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 2"
},
"World 3": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 3"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.tools.pv_slicer",
"glue.viewers.histogram",
"glue.viewers.table",
"glue_vispy_viewers.volume",
"glue.plugins.exporters.plotly",
"glue.plugins.export_d3po",
"glue.viewers.image",
"glue.plugins.tools.spectrum_tool",
"glue_vispy_viewers.scatter",
"glue.viewers.scatter",
"glue.plugins.coordinate_helpers",
"glue.core.data_exporters"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageWidget"
]
]
},
"array": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"array_0",
"Component"
],
[
"Pixel Axis 0",
"CoordinateComponent"
],
[
"Pixel Axis 1",
"CoordinateComponent_0"
],
[
"Pixel Axis 2",
"CoordinateComponent_1"
],
[
"Pixel Axis 3",
"CoordinateComponent_2"
],
[
"World 0",
"CoordinateComponent_3"
],
[
"World 1",
"CoordinateComponent_4"
],
[
"World 2",
"CoordinateComponent_5"
],
[
"World 3",
"CoordinateComponent_6"
]
],
"coords": "Coordinates",
"label": "array",
"primary_owner": [
"array_0",
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3",
"World 0",
"World 1",
"World 2",
"World 3"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "5e2335ce-5613-4fb1-aa58-1cf342f7b755"
},
"array_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "array"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_rgb_v0.glu 0000644 0001750 0001750 00000017004 13502206677 025651 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAA=="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoIAAAAAAAAAAkAAAAAAAAACgAAAAAAAAALAAAAAAAAAA=="
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoEAAAAAAAAAAUAAAAAAAAABgAAAAAAAAAHAAAAAAAAAA=="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DS9Normalize": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": null,
"clip_lo": null,
"contrast": 1.0,
"stretch": "arcsinh",
"vmax": 3,
"vmin": 0
},
"DS9Normalize_0": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": 99,
"clip_lo": 1,
"contrast": 1.0,
"stretch": "linear",
"vmax": null,
"vmin": null
},
"DS9Normalize_1": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": null,
"clip_lo": null,
"contrast": 1.0,
"stretch": "linear",
"vmax": 5.0,
"vmin": -5.0
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"c",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"Component_0",
"Component_1"
],
"data": [
"rgbcube"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2"
],
"subset_group_count": 0
},
"ImageWidget": {
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.RGBImageLayerArtist",
"b": "b",
"bnorm": "DS9Normalize",
"color_visible": [
true,
false,
true
],
"g": "c",
"gnorm": "DS9Normalize_0",
"layer": "rgbcube",
"norm": "DS9Normalize_0",
"r": "a",
"rnorm": "DS9Normalize_1",
"visible": true,
"zorder": 1
}
],
"pos": [
0,
0
],
"properties": {
"attribute": "a",
"batt": "b",
"data": "rgbcube",
"gatt": "c",
"ratt": "a",
"rgb_mode": true,
"rgb_viz": [
true,
false,
true
],
"slice": [
"y",
"x"
]
},
"session": "Session",
"size": [
600,
400
]
},
"Pixel Axis 0 [y]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [y]"
},
"Pixel Axis 1 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.tools.pv_slicer",
"glue.viewers.histogram",
"glue.viewers.table",
"glue_vispy_viewers.volume",
"glue.plugins.exporters.plotly",
"glue.plugins.export_d3po",
"glue.viewers.image",
"glue.plugins.tools.spectrum_tool",
"glue_vispy_viewers.scatter",
"glue.viewers.scatter",
"glue.plugins.coordinate_helpers",
"glue.core.data_exporters"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageWidget"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"c": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "c"
},
"rgbcube": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [y]",
"CoordinateComponent"
],
[
"Pixel Axis 1 [x]",
"CoordinateComponent_0"
],
[
"World 0",
"CoordinateComponent_1"
],
[
"World 1",
"CoordinateComponent_2"
],
[
"c",
"Component_0"
],
[
"b",
"Component_1"
]
],
"coords": "Coordinates",
"label": "rgbcube",
"primary_owner": [
"a",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"c",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "d2fdde54-ab42-4370-9670-4b9906da51f2"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_v0.glu 0000644 0001750 0001750 00000037157 13502206677 025032 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAA=="
},
"units": ""
},
"ComponentLink": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"World 0"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"a"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_0": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"World 1"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"b"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_1": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"b"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"World 1"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_2": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"a"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"World 0"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsKSwgfSAgICAgICAgICAgIAoAAAAAAAD4PwAAAAAAAABA"
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsKSwgfSAgICAgICAgICAgIAoAAAAAAADgPwAAAAAAAABA"
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"World 0_0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0_0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"CoordinateComponent_3": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_4": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"DS9Normalize": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": 99.0,
"clip_lo": 1.0,
"contrast": 1.0,
"stretch": "sqrt",
"vmax": null,
"vmin": null
},
"DS9Normalize_0": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": null,
"clip_lo": null,
"contrast": 1.0,
"stretch": "linear",
"vmax": 2.0,
"vmin": -2.0
},
"DS9Normalize_1": {
"_type": "glue.viewers.image.ds9norm.DS9Normalize",
"bias": 0.5,
"clip_hi": null,
"clip_lo": null,
"contrast": 1.0,
"stretch": "arcsinh",
"vmax": 4,
"vmin": 1
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"data1_0",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"a",
"b",
"a",
"Pixel Axis 0 [x]",
"World 0_0",
"b",
"Pixel Axis 1 [x]",
"World 1",
"Pixel Axis 0 [y]",
"World 0"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"DerivedComponent",
"DerivedComponent_0",
"Component_0",
"CoordinateComponent_3",
"CoordinateComponent_4",
"Component_1",
"DerivedComponent_1",
"DerivedComponent_2",
"DerivedComponent_3",
"DerivedComponent_4"
],
"data": [
"data1",
"data2"
],
"groups": [
"Subset 1"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"ComponentLink",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"ComponentLink_0",
"CoordinateComponentLink_4"
],
"subset_group_count": 1
},
"DerivedComponent": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink"
},
"DerivedComponent_0": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_0"
},
"DerivedComponent_1": {
"_type": "glue.core.component.DerivedComponent",
"link": "CoordinateComponentLink_2"
},
"DerivedComponent_2": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_1"
},
"DerivedComponent_3": {
"_type": "glue.core.component.DerivedComponent",
"link": "CoordinateComponentLink_3"
},
"DerivedComponent_4": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_2"
},
"ImageWidget": {
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"layer": "data1",
"norm": "DS9Normalize",
"visible": true,
"zorder": 1
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "data2",
"visible": true,
"xatt": "Pixel Axis 1 [x]",
"yatt": "Pixel Axis 0 [y]",
"zorder": 2
},
{
"_type": "glue.viewers.image.layer_artist.SubsetImageLayerArtist",
"layer": "Subset 1_0",
"visible": false,
"zorder": 3
}
],
"pos": [
-1,
1
],
"properties": {
"attribute": "data1_0",
"batt": null,
"data": "data1",
"gatt": null,
"ratt": null,
"rgb_mode": false,
"rgb_viz": [
true,
true,
true
],
"slice": [
"y",
"x"
]
},
"session": "Session",
"size": [
568,
490
]
},
"ImageWidget_0": {
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"layer": "data1",
"norm": "DS9Normalize_1",
"visible": true,
"zorder": 1
},
{
"_type": "glue.viewers.image.layer_artist.SubsetImageLayerArtist",
"layer": "Subset 1_0",
"visible": true,
"zorder": 2
}
],
"pos": [
568,
1
],
"properties": {
"attribute": "data1_0",
"batt": null,
"data": "data1",
"gatt": null,
"ratt": null,
"rgb_mode": false,
"rgb_viz": [
true,
true,
true
],
"slice": [
"y",
"x"
]
},
"session": "Session",
"size": [
606,
489
]
},
"ImageWidget_1": {
"_type": "glue.viewers.image.qt.viewer_widget.ImageWidget",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"layer": "data1",
"norm": "DS9Normalize_0",
"visible": true,
"zorder": 1
},
{
"_type": "glue.viewers.image.layer_artist.SubsetImageLayerArtist",
"layer": "Subset 1_0",
"visible": true,
"zorder": 2
}
],
"pos": [
568,
487
],
"properties": {
"attribute": "data1_0",
"batt": null,
"data": "data1",
"gatt": null,
"ratt": null,
"rgb_mode": false,
"rgb_viz": [
true,
true,
true
],
"slice": [
"y",
"x"
]
},
"session": "Session",
"size": [
600,
400
]
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Pixel Axis 0 [y]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [y]"
},
"Pixel Axis 1 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1 [x]"
},
"PolygonalROI": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
0.7380952380952381,
1.847619047619048,
1.847619047619048,
0.7380952380952381,
0.7380952380952381
],
"vy": [
0.5866666666666664,
0.5866666666666664,
1.7666666666666662,
1.7666666666666662,
0.5866666666666664
]
},
"RoiSubsetState": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI",
"xatt": "Pixel Axis 1 [x]",
"yatt": "Pixel Axis 0 [y]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RoiSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1_0",
"Subset 1_1"
]
},
"Subset 1_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 1_1": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 0_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.tools.pv_slicer",
"glue.viewers.histogram",
"glue.viewers.table",
"glue_vispy_viewers.volume",
"glue.plugins.exporters.plotly",
"glue.plugins.export_d3po",
"glue.viewers.image",
"glue.plugins.tools.spectrum_tool",
"glue_vispy_viewers.scatter",
"glue.viewers.scatter",
"glue.plugins.coordinate_helpers",
"glue.core.data_exporters"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageWidget",
"ImageWidget_0",
"ImageWidget_1"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"data1": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"data1_0",
"Component"
],
[
"Pixel Axis 0 [y]",
"CoordinateComponent"
],
[
"Pixel Axis 1 [x]",
"CoordinateComponent_0"
],
[
"World 0",
"CoordinateComponent_1"
],
[
"World 1",
"CoordinateComponent_2"
],
[
"a",
"DerivedComponent"
],
[
"b",
"DerivedComponent_0"
]
],
"coords": "Coordinates",
"label": "data1",
"primary_owner": [
"data1_0",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1_0"
],
"uuid": "daad10a3-6ad4-4dd4-841a-ca2071dbe467"
},
"data1_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "data1"
},
"data2": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component_0"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent_3"
],
[
"World 0_0",
"CoordinateComponent_4"
],
[
"b",
"Component_1"
],
[
"Pixel Axis 1 [x]",
"DerivedComponent_1"
],
[
"World 1",
"DerivedComponent_2"
],
[
"Pixel Axis 0 [y]",
"DerivedComponent_3"
],
[
"World 0",
"DerivedComponent_4"
]
],
"coords": "Coordinates_0",
"label": "data2",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0_0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 1.0,
"color": "#e60010",
"linestyle": "solid",
"linewidth": 1,
"marker": "^",
"markersize": 3
},
"subsets": [
"Subset 1_1"
],
"uuid": "e0521c8f-3f02-41b8-8746-a71aa9ae5f49"
}
}
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_v1.glu 0000644 0001750 0001750 00000050130 13644362032 025010 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ImageLayerState",
"ScatterLayerState",
"ImageSubsetLayerState"
]
},
"CallbackList_0": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ImageLayerState_0",
"ImageSubsetLayerState_0"
]
},
"CallbackList_1": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ImageLayerState_1",
"ImageSubsetLayerState_1"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAAEAAAAAAAAAA=="
},
"units": ""
},
"ComponentLink": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"a"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"World 0"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_0": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"World 1"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"b"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_1": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"World 0"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"a"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"ComponentLink_2": {
"_type": "glue.core.component_link.ComponentLink",
"frm": [
"b"
],
"hidden": false,
"inverse": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
},
"to": [
"World 1"
],
"using": {
"_type": "types.FunctionType",
"function": "glue.core.component_link.identity"
}
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsKSwgfSAgICAgICAgICAgIAoAAAAAAAD4PwAAAAAAAABA"
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsKSwgfSAgICAgICAgICAgIAoAAAAAAADgPwAAAAAAAABA"
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"World 0_0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0_0"
]
},
"CoordinateComponentLink_10": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0_0"
]
},
"CoordinateComponentLink_5": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_6": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates_0",
"frm": [
"World 0_0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_7": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponentLink_8": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_9": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"CoordinateComponent_3": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_4": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"Coordinates_0": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"data1_0",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"a",
"b",
"a",
"Pixel Axis 0 [x]",
"World 0_0",
"b",
"Pixel Axis 1 [x]",
"World 1",
"Pixel Axis 0 [y]",
"World 0"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"DerivedComponent",
"DerivedComponent_0",
"Component_0",
"CoordinateComponent_3",
"CoordinateComponent_4",
"Component_1",
"DerivedComponent_1",
"DerivedComponent_2",
"DerivedComponent_3",
"DerivedComponent_4"
],
"data": [
"data1",
"data2"
],
"groups": [
"Subset 1"
],
"links": [
"ComponentLink",
"ComponentLink_0",
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"ComponentLink_1",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6",
"CoordinateComponentLink_7",
"CoordinateComponentLink_8",
"ComponentLink_2",
"CoordinateComponentLink_9",
"CoordinateComponentLink_10"
],
"subset_group_count": 1
},
"DerivedComponent": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_1"
},
"DerivedComponent_0": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_0"
},
"DerivedComponent_1": {
"_type": "glue.core.component.DerivedComponent",
"link": "CoordinateComponentLink_3"
},
"DerivedComponent_2": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink_2"
},
"DerivedComponent_3": {
"_type": "glue.core.component.DerivedComponent",
"link": "CoordinateComponentLink_7"
},
"DerivedComponent_4": {
"_type": "glue.core.component.DerivedComponent",
"link": "ComponentLink"
},
"ImageLayerState": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "data1_0",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__0.35",
"contrast": 1.0,
"global_sync": true,
"layer": "data1",
"percentile": 99,
"stretch": "st__sqrt",
"v_max": 3.985,
"v_min": 1.015,
"visible": true,
"zorder": 2
}
},
"ImageLayerState_0": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "data1_0",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__0.35",
"contrast": 1.0,
"global_sync": true,
"layer": "data1",
"percentile": "st__Custom",
"stretch": "st__arcsinh",
"v_max": 4,
"v_min": 1,
"visible": true,
"zorder": 2
}
},
"ImageLayerState_1": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "data1_0",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__0.35",
"contrast": 1.0,
"global_sync": true,
"layer": "data1",
"percentile": "st__Custom",
"stretch": "st__linear",
"v_max": 2.0,
"v_min": -2.0,
"visible": true,
"zorder": 2
}
},
"ImageSubsetLayerState": {
"_type": "glue.viewers.image.state.ImageSubsetLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": false,
"zorder": 4
}
},
"ImageSubsetLayerState_0": {
"_type": "glue.viewers.image.state.ImageSubsetLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": true,
"zorder": 3
}
},
"ImageSubsetLayerState_1": {
"_type": "glue.viewers.image.state.ImageSubsetLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": true,
"zorder": 3
}
},
"ImageViewer": {
"_protocol": 1,
"_type": "glue.viewers.image.qt.data_viewer.ImageViewer",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState"
},
{
"_type": "glue.viewers.image.layer_artist.ImageSubsetLayerArtist",
"state": "ImageSubsetLayerState"
}
],
"pos": [
-1,
1
],
"session": "Session",
"size": [
568,
490
],
"state": {
"values": {
"aspect": "st__equal",
"color_mode": "st__Colormaps",
"layers": "CallbackList",
"reference_data": "data1",
"slices": [
0,
0
],
"x_att": "Pixel Axis 1 [x]",
"x_att_world": "World 1",
"x_log": false,
"x_max": 1.937,
"x_min": -0.936,
"y_att": "Pixel Axis 0 [y]",
"y_att_world": "World 0",
"y_log": false,
"y_max": 1.5,
"y_min": -0.5
}
}
},
"ImageViewer_0": {
"_protocol": 1,
"_type": "glue.viewers.image.qt.data_viewer.ImageViewer",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState_0"
},
{
"_type": "glue.viewers.image.layer_artist.ImageSubsetLayerArtist",
"state": "ImageSubsetLayerState_0"
}
],
"pos": [
568,
1
],
"session": "Session",
"size": [
606,
489
],
"state": {
"values": {
"aspect": "st__equal",
"color_mode": "st__Colormaps",
"layers": "CallbackList_0",
"reference_data": "data1",
"slices": [
0,
0
],
"x_att": "Pixel Axis 1 [x]",
"x_att_world": "World 1",
"x_log": false,
"x_max": 1.937,
"x_min": -0.936,
"y_att": "Pixel Axis 0 [y]",
"y_att_world": "World 0",
"y_log": false,
"y_max": 1.5,
"y_min": -0.5
}
}
},
"ImageViewer_1": {
"_protocol": 1,
"_type": "glue.viewers.image.qt.data_viewer.ImageViewer",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState_1"
},
{
"_type": "glue.viewers.image.layer_artist.ImageSubsetLayerArtist",
"state": "ImageSubsetLayerState_1"
}
],
"pos": [
569,
488
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__equal",
"color_mode": "st__Colormaps",
"layers": "CallbackList_1",
"reference_data": "data1",
"slices": [
0,
0
],
"x_att": "Pixel Axis 1 [x]",
"x_att_world": "World 1",
"x_log": false,
"x_max": 1.937,
"x_min": -0.936,
"y_att": "Pixel Axis 0 [y]",
"y_att_world": "World 0",
"y_log": false,
"y_max": 1.5,
"y_min": -0.5
}
}
},
"LinearSegmentedColormap": {
"_type": "matplotlib.colors.LinearSegmentedColormap",
"cmap": "gray"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"Pixel Axis 0 [y]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [y]"
},
"Pixel Axis 1 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1 [x]"
},
"PolygonalROI": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
0.7380952380952381,
1.847619047619048,
1.847619047619048,
0.7380952380952381,
0.7380952380952381
],
"vy": [
0.5866666666666664,
0.5866666666666664,
1.7666666666666662,
1.7666666666666662,
0.5866666666666664
]
},
"RoiSubsetState": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI",
"xatt": "Pixel Axis 1 [x]",
"yatt": "Pixel Axis 0 [y]"
},
"ScatterLayerState": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 1.0,
"color": "st__#e60010",
"layer": "data2",
"size": 3,
"visible": true,
"zorder": 3
}
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RoiSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1_0",
"Subset 1_1"
]
},
"Subset 1_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 1_1": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 0_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.viewers.image",
"glue.plugins.exporters.plotly",
"specviz.app",
"glue.viewers.scatter",
"glue.viewers.histogram",
"glue.core.data_exporters",
"glue.plugins.tools.spectrum_tool",
"glue.viewers.table",
"glue_medical",
"glue_vispy_viewers.scatter",
"glue_vispy_viewers.volume",
"glue.plugins.coordinate_helpers",
"glue.plugins.tools.pv_slicer",
"glue.plugins.export_d3po"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageViewer",
"ImageViewer_0",
"ImageViewer_1"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"data1": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"data1_0",
"Component"
],
[
"Pixel Axis 0 [y]",
"CoordinateComponent"
],
[
"Pixel Axis 1 [x]",
"CoordinateComponent_0"
],
[
"World 0",
"CoordinateComponent_1"
],
[
"World 1",
"CoordinateComponent_2"
],
[
"a",
"DerivedComponent"
],
[
"b",
"DerivedComponent_0"
]
],
"coords": "Coordinates",
"label": "data1",
"primary_owner": [
"data1_0",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1_0"
],
"uuid": "daad10a3-6ad4-4dd4-841a-ca2071dbe467"
},
"data1_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "data1"
},
"data2": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component_0"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent_3"
],
[
"World 0_0",
"CoordinateComponent_4"
],
[
"b",
"Component_1"
],
[
"Pixel Axis 1 [x]",
"DerivedComponent_1"
],
[
"World 1",
"DerivedComponent_2"
],
[
"Pixel Axis 0 [y]",
"DerivedComponent_3"
],
[
"World 0",
"DerivedComponent_4"
]
],
"coords": "Coordinates_0",
"label": "data2",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0_0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 1.0,
"color": "#e60010",
"linestyle": "solid",
"linewidth": 1,
"marker": "^",
"markersize": 3
},
"subsets": [
"Subset 1_1"
],
"uuid": "e0521c8f-3f02-41b8-8746-a71aa9ae5f49"
}
}
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_rgb_v1.glu 0000644 0001750 0001750 00000023442 13644362032 025650 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ImageLayerState",
"ImageLayerState_0",
"ImageLayerState_1"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAA=="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoIAAAAAAAAAAkAAAAAAAAACgAAAAAAAAALAAAAAAAAAA=="
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDIsIDIpLCB9ICAgICAgICAgIAoEAAAAAAAAAAUAAAAAAAAABgAAAAAAAAAHAAAAAAAAAA=="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_5": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1 [x]"
]
},
"CoordinateComponentLink_6": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [y]"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"c",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"Component_0",
"Component_1"
],
"data": [
"rgbcube"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6"
],
"subset_group_count": 0
},
"ImageLayerState": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "a",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__r",
"contrast": 1.0,
"global_sync": false,
"layer": "rgbcube",
"percentile": "st__Custom",
"stretch": "st__linear",
"v_max": 5.0,
"v_min": -5.0,
"visible": true,
"zorder": 2
}
},
"ImageLayerState_0": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "c",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__g",
"contrast": 1.0,
"global_sync": false,
"layer": "rgbcube",
"percentile": 99,
"stretch": "st__linear",
"v_max": 10.985,
"v_min": 8.015,
"visible": false,
"zorder": 3
}
},
"ImageLayerState_1": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "b",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__b",
"contrast": 1.0,
"global_sync": false,
"layer": "rgbcube",
"percentile": "st__Custom",
"stretch": "st__arcsinh",
"v_max": 3,
"v_min": 0,
"visible": true,
"zorder": 4
}
},
"ImageViewer": {
"_protocol": 1,
"_type": "glue.viewers.image.qt.data_viewer.ImageViewer",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState"
},
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState_0"
},
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState_1"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__equal",
"color_mode": "st__One color per layer",
"layers": "CallbackList",
"reference_data": "rgbcube",
"slices": [
0,
0
],
"x_att": "Pixel Axis 1 [x]",
"x_att_world": "World 1",
"x_log": false,
"x_max": 2.5253556681900653,
"x_min": -1.4613891239424421,
"y_att": "Pixel Axis 0 [y]",
"y_att_world": "World 0",
"y_log": false,
"y_max": 1.555040949314538,
"y_min": -0.5351753331368783
}
}
},
"LinearSegmentedColormap": {
"_type": "matplotlib.colors.LinearSegmentedColormap",
"cmap": "gray"
},
"Pixel Axis 0 [y]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [y]"
},
"Pixel Axis 1 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1 [x]"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.core.data_exporters",
"glue.viewers.image",
"glue.viewers.scatter",
"glue_vispy_viewers.volume",
"glue_medical",
"glue.plugins.tools.pv_slicer",
"glue.plugins.coordinate_helpers",
"glue.viewers.table",
"glue_vispy_viewers.scatter",
"glue.plugins.export_d3po",
"glue.viewers.histogram",
"glue.plugins.tools.spectrum_tool",
"glue.plugins.exporters.plotly",
"specviz.app"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageViewer"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"c": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "c"
},
"rgbcube": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [y]",
"CoordinateComponent"
],
[
"Pixel Axis 1 [x]",
"CoordinateComponent_0"
],
[
"World 0",
"CoordinateComponent_1"
],
[
"World 1",
"CoordinateComponent_2"
],
[
"c",
"Component_0"
],
[
"b",
"Component_1"
]
],
"coords": "Coordinates",
"label": "rgbcube",
"primary_owner": [
"a",
"Pixel Axis 0 [y]",
"Pixel Axis 1 [x]",
"World 0",
"World 1",
"c",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "d2fdde54-ab42-4370-9670-4b9906da51f2"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/data/image_cube_v1.glu 0000644 0001750 0001750 00000032414 13644362032 026013 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ImageLayerState"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsIDQsIDIsIDUpLCB9ICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAAoAAAAAAAAACwAAAAAAAAAMAAAAAAAAAA0AAAAAAAAADgAAAAAAAAAPAAAAAAAAABAAAAAAAAAAEQAAAAAAAAASAAAAAAAAABMAAAAAAAAAFAAAAAAAAAAVAAAAAAAAABYAAAAAAAAAFwAAAAAAAAAYAAAAAAAAABkAAAAAAAAAGgAAAAAAAAAbAAAAAAAAABwAAAAAAAAAHQAAAAAAAAAeAAAAAAAAAB8AAAAAAAAAIAAAAAAAAAAhAAAAAAAAACIAAAAAAAAAIwAAAAAAAAAkAAAAAAAAACUAAAAAAAAAJgAAAAAAAAAnAAAAAAAAACgAAAAAAAAAKQAAAAAAAAAqAAAAAAAAACsAAAAAAAAALAAAAAAAAAAtAAAAAAAAAC4AAAAAAAAALwAAAAAAAAAwAAAAAAAAADEAAAAAAAAAMgAAAAAAAAAzAAAAAAAAADQAAAAAAAAANQAAAAAAAAA2AAAAAAAAADcAAAAAAAAAOAAAAAAAAAA5AAAAAAAAADoAAAAAAAAAOwAAAAAAAAA8AAAAAAAAAD0AAAAAAAAAPgAAAAAAAAA/AAAAAAAAAEAAAAAAAAAAQQAAAAAAAABCAAAAAAAAAEMAAAAAAAAARAAAAAAAAABFAAAAAAAAAEYAAAAAAAAARwAAAAAAAABIAAAAAAAAAEkAAAAAAAAASgAAAAAAAABLAAAAAAAAAEwAAAAAAAAATQAAAAAAAABOAAAAAAAAAE8AAAAAAAAAUAAAAAAAAABRAAAAAAAAAFIAAAAAAAAAUwAAAAAAAABUAAAAAAAAAFUAAAAAAAAAVgAAAAAAAABXAAAAAAAAAFgAAAAAAAAAWQAAAAAAAABaAAAAAAAAAFsAAAAAAAAAXAAAAAAAAABdAAAAAAAAAF4AAAAAAAAAXwAAAAAAAABgAAAAAAAAAGEAAAAAAAAAYgAAAAAAAABjAAAAAAAAAGQAAAAAAAAAZQAAAAAAAABmAAAAAAAAAGcAAAAAAAAAaAAAAAAAAABpAAAAAAAAAGoAAAAAAAAAawAAAAAAAABsAAAAAAAAAG0AAAAAAAAAbgAAAAAAAABvAAAAAAAAAHAAAAAAAAAAcQAAAAAAAAByAAAAAAAAAHMAAAAAAAAAdAAAAAAAAAB1AAAAAAAAAHYAAAAAAAAAdwAAAAAAAAA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 2,
"pix2world": false,
"to": [
"Pixel Axis 2"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 3,
"pix2world": false,
"to": [
"Pixel Axis 3"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 2,
"pix2world": false,
"to": [
"Pixel Axis 2"
]
},
"CoordinateComponentLink_10": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_11": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 2,
"pix2world": true,
"to": [
"World 2"
]
},
"CoordinateComponentLink_12": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0"
]
},
"CoordinateComponentLink_13": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 1,
"pix2world": true,
"to": [
"World 1"
]
},
"CoordinateComponentLink_14": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 3,
"pix2world": false,
"to": [
"Pixel Axis 3"
]
},
"CoordinateComponentLink_3": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0"
]
},
"CoordinateComponentLink_4": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 2,
"pix2world": true,
"to": [
"World 2"
]
},
"CoordinateComponentLink_5": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_6": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 3,
"pix2world": true,
"to": [
"World 3"
]
},
"CoordinateComponentLink_7": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1"
]
},
"CoordinateComponentLink_8": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3"
],
"index": 3,
"pix2world": true,
"to": [
"World 3"
]
},
"CoordinateComponentLink_9": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0",
"World 1",
"World 2",
"World 3"
],
"index": 1,
"pix2world": false,
"to": [
"Pixel Axis 1"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": false
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 3,
"world": false
},
"CoordinateComponent_3": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_4": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"CoordinateComponent_5": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": true
},
"CoordinateComponent_6": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 3,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"array_0",
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3",
"World 0",
"World 1",
"World 2",
"World 3"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"CoordinateComponent_3",
"CoordinateComponent_4",
"CoordinateComponent_5",
"CoordinateComponent_6"
],
"data": [
"array"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2",
"CoordinateComponentLink_3",
"CoordinateComponentLink_4",
"CoordinateComponentLink_5",
"CoordinateComponentLink_6",
"CoordinateComponentLink_7",
"CoordinateComponentLink_8",
"CoordinateComponentLink_9",
"CoordinateComponentLink_10",
"CoordinateComponentLink_11",
"CoordinateComponentLink_12",
"CoordinateComponentLink_13",
"CoordinateComponentLink_14"
],
"subset_group_count": 0
},
"ImageLayerState": {
"_type": "glue.viewers.image.state.ImageLayerState",
"values": {
"alpha": 0.8,
"attribute": "array_0",
"bias": 0.5,
"cmap": "LinearSegmentedColormap",
"color": "st__0.35",
"contrast": 1.0,
"global_sync": true,
"layer": "array",
"percentile": 100,
"stretch": "st__linear",
"v_max": 119.0,
"v_min": 0.0,
"visible": true,
"zorder": 2
}
},
"ImageViewer": {
"_protocol": 1,
"_type": "glue.viewers.image.qt.data_viewer.ImageViewer",
"layers": [
{
"_type": "glue.viewers.image.layer_artist.ImageLayerArtist",
"state": "ImageLayerState"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
731,
529
],
"state": {
"values": {
"aspect": "st__equal",
"color_mode": "st__Colormaps",
"layers": "CallbackList",
"reference_data": "array",
"slices": [
2,
0,
0,
1
],
"x_att": "Pixel Axis 2",
"x_att_world": "World 2",
"x_log": false,
"x_max": 4.075455766965458,
"x_min": -2.932007545418843,
"y_att": "Pixel Axis 1",
"y_att_world": "World 1",
"y_log": false,
"y_max": 3.6720458592035916,
"y_min": -0.6781873651245816
}
}
},
"LinearSegmentedColormap": {
"_type": "matplotlib.colors.LinearSegmentedColormap",
"cmap": "gray"
},
"Pixel Axis 0": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0"
},
"Pixel Axis 1": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"hidden": true,
"label": "Pixel Axis 1"
},
"Pixel Axis 2": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 2,
"hidden": true,
"label": "Pixel Axis 2"
},
"Pixel Axis 3": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 3,
"hidden": true,
"label": "Pixel Axis 3"
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 1"
},
"World 2": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 2"
},
"World 3": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 3"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.viewers.scatter",
"glue.viewers.table",
"glue_medical",
"specviz.app",
"glue.plugins.exporters.plotly",
"glue.core.data_exporters",
"glue.plugins.export_d3po",
"glue_vispy_viewers.volume",
"glue.plugins.tools.spectrum_tool",
"glue.plugins.coordinate_helpers",
"glue.viewers.histogram",
"glue.plugins.tools.pv_slicer",
"glue_vispy_viewers.scatter",
"glue.viewers.image"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ImageViewer"
]
]
},
"array": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"array_0",
"Component"
],
[
"Pixel Axis 0",
"CoordinateComponent"
],
[
"Pixel Axis 1",
"CoordinateComponent_0"
],
[
"Pixel Axis 2",
"CoordinateComponent_1"
],
[
"Pixel Axis 3",
"CoordinateComponent_2"
],
[
"World 0",
"CoordinateComponent_3"
],
[
"World 1",
"CoordinateComponent_4"
],
[
"World 2",
"CoordinateComponent_5"
],
[
"World 3",
"CoordinateComponent_6"
]
],
"coords": "Coordinates",
"label": "array",
"primary_owner": [
"array_0",
"Pixel Axis 0",
"Pixel Axis 1",
"Pixel Axis 2",
"Pixel Axis 3",
"World 0",
"World 1",
"World 2",
"World 3"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "5e2335ce-5613-4fb1-aa58-1cf342f7b755"
},
"array_0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "array"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000102213 13752534424 025607 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import os
import gc
from collections import Counter
import pytest
from astropy.wcs import WCS
import numpy as np
from numpy.testing import assert_allclose
from glue.viewers.image.frb_artist import FRBArtist
from glue.core.coordinates import IdentityCoordinates
from glue.core.message import SubsetUpdateMessage
from glue.core import HubListener, Data
from glue.core.roi import XRangeROI, RectangularROI
from glue.core.subset import RoiSubsetState
from glue.utils.qt import combo_as_string, process_events
from glue.viewers.matplotlib.qt.tests.test_data_viewer import BaseTestMatplotlibDataViewer
from glue.core.state import GlueUnSerializer
from glue.app.qt.layer_tree_widget import LayerTreeWidget
from glue.viewers.scatter.state import ScatterLayerState
from glue.viewers.image.state import ImageLayerState, ImageSubsetLayerState, AggregateSlice
from glue.core.link_helpers import LinkSame
from glue.app.qt import GlueApplication
from glue.core.fixed_resolution_buffer import ARRAY_CACHE, PIXEL_CACHE
from glue.core.data_derived import IndexedData
from ..data_viewer import ImageViewer
DATA = os.path.join(os.path.dirname(__file__), 'data')
class TestImageCommon(BaseTestMatplotlibDataViewer):
def init_data(self):
return Data(label='d1', x=np.arange(24).reshape((2, 3, 4)), y=np.ones((2, 3, 4)))
viewer_cls = ImageViewer
@pytest.mark.skip()
def test_double_add_ignored(self):
pass
def test_update_data_processed_if_data_present(self):
# Patch for the main test of the same name - we need to explicilty set
# global_sync to True here for things to work correctly.
self.init_draw_count()
self.data_collection.append(self.data)
self.viewer.add_data(self.data)
ct0 = self.draw_count
self.viewer.state.layers[0].global_sync = True
self.data.style.color = 'blue'
assert self.draw_count > ct0
def test_slice_change_single_draw(self):
# Regression test for a bug that caused Matplotlib to draw once per
# data/subset when changing slices.
self.viewer.add_data(self.data)
self.data_collection.new_subset_group(label='a', subset_state=self.data.id['x'] > 1)
self.data_collection.new_subset_group(label='b', subset_state=self.data.id['x'] > 2)
self.data_collection.new_subset_group(label='c', subset_state=self.data.id['x'] > 3)
self.init_draw_count()
assert self.draw_count == 0
self.viewer.state.slices = (1, 1, 1)
assert self.draw_count == 1
class MyCoords(IdentityCoordinates):
def __init__(self, n_dim=2):
super().__init__(n_dim=n_dim)
@property
def world_axis_names(self):
return ['Apple', 'Banana']
class TestImageViewer(object):
def setup_method(self, method):
self.coords = MyCoords()
self.image1 = Data(label='image1', x=[[1, 2], [3, 4]], y=[[4, 5], [2, 3]])
self.image2 = Data(label='image2', a=[[3, 3], [2, 2]], b=[[4, 4], [3, 2]],
coords=self.coords)
self.catalog = Data(label='catalog', c=[1, 3, 2], d=[4, 3, 3])
self.hypercube = Data(label='hypercube', x=np.arange(120).reshape((2, 3, 4, 5)))
# Create data versions with WCS coordinates
self.image1_wcs = Data(label='image1_wcs', x=self.image1['x'],
coords=WCS(naxis=2))
self.hypercube_wcs = Data(label='hypercube_wcs', x=self.hypercube['x'],
coords=WCS(naxis=4))
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.image1)
self.data_collection.append(self.image2)
self.data_collection.append(self.catalog)
self.data_collection.append(self.hypercube)
self.data_collection.append(self.image1_wcs)
self.data_collection.append(self.hypercube_wcs)
self.viewer = self.application.new_data_viewer(ImageViewer)
self.data_collection.register_to_hub(self.hub)
self.viewer.register_to_hub(self.hub)
self.options_widget = self.viewer.options_widget()
def teardown_method(self, method):
# Properly close viewer and application
self.viewer.close()
self.viewer = None
self.application.close()
self.application = None
# Make sure cache is empty
if len(PIXEL_CACHE) > 0:
raise Exception("Pixel cache contains {0} elements".format(len(PIXEL_CACHE)))
if len(ARRAY_CACHE) > 0:
raise Exception("Array cache contains {0} elements".format(len(ARRAY_CACHE)))
def test_basic(self):
# Check defaults when we add data
self.viewer.add_data(self.image1)
assert combo_as_string(self.options_widget.ui.combosel_x_att_world) == 'Coordinate components:Pixel Axis 0 [y]:Pixel Axis 1 [x]'
assert combo_as_string(self.options_widget.ui.combosel_y_att_world) == 'Coordinate components:Pixel Axis 0 [y]:Pixel Axis 1 [x]'
assert self.viewer.axes.get_xlabel() == 'Pixel Axis 1 [x]'
assert self.viewer.state.x_att_world is self.image1.id['Pixel Axis 1 [x]']
assert self.viewer.state.x_att is self.image1.pixel_component_ids[1]
assert_allclose(self.viewer.state.x_min, -0.8419913419913423)
assert_allclose(self.viewer.state.x_max, +1.8419913419913423)
assert self.viewer.axes.get_ylabel() == 'Pixel Axis 0 [y]'
assert self.viewer.state.y_att_world is self.image1.id['Pixel Axis 0 [y]']
assert self.viewer.state.y_att is self.image1.pixel_component_ids[0]
assert self.viewer.state.y_min == -0.5
assert self.viewer.state.y_max == +1.5
assert not self.viewer.state.x_log
assert not self.viewer.state.y_log
assert len(self.viewer.state.layers) == 1
def test_custom_coords(self):
# Check defaults when we add data with coordinates
self.viewer.add_data(self.image2)
assert combo_as_string(self.options_widget.ui.combosel_x_att_world) == 'Coordinate components:Banana:Apple'
assert combo_as_string(self.options_widget.ui.combosel_x_att_world) == 'Coordinate components:Banana:Apple'
assert self.viewer.axes.get_xlabel() == 'Apple'
assert self.viewer.state.x_att_world is self.image2.id['Apple']
assert self.viewer.state.x_att is self.image2.pixel_component_ids[1]
assert self.viewer.axes.get_ylabel() == 'Banana'
assert self.viewer.state.y_att_world is self.image2.id['Banana']
assert self.viewer.state.y_att is self.image2.pixel_component_ids[0]
def test_flip(self):
self.viewer.add_data(self.image1)
x_min_start = self.viewer.state.x_min
x_max_start = self.viewer.state.x_max
self.options_widget.button_flip_x.click()
assert self.viewer.state.x_min == x_max_start
assert self.viewer.state.x_max == x_min_start
y_min_start = self.viewer.state.y_min
y_max_start = self.viewer.state.y_max
self.options_widget.button_flip_y.click()
assert self.viewer.state.y_min == y_max_start
assert self.viewer.state.y_max == y_min_start
def test_combo_updates_with_component_add(self):
self.viewer.add_data(self.image1)
self.image1.add_component([[9, 9], [8, 8]], 'z')
assert self.viewer.state.x_att_world is self.image1.id['Pixel Axis 1 [x]']
assert self.viewer.state.y_att_world is self.image1.id['Pixel Axis 0 [y]']
# TODO: there should be an easier way to do this
layer_style_editor = self.viewer._view.layout_style_widgets[self.viewer.layers[0]]
assert combo_as_string(layer_style_editor.ui.combosel_attribute) == 'x:y:z'
def test_apply_roi(self):
self.viewer.add_data(self.image1)
roi = RectangularROI(0.4, 1.6, -0.6, 0.6)
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert len(self.image1.subsets) == 1
assert_allclose(self.image1.subsets[0].to_mask(), [[0, 1], [0, 0]])
state = self.image1.subsets[0].subset_state
assert isinstance(state, RoiSubsetState)
def test_apply_roi_empty(self):
# Make sure that doing an ROI selection on an empty viewer doesn't
# produce error messsages
roi = XRangeROI(-0.2, 0.1)
self.viewer.apply_roi(roi)
def test_identical(self):
# Check what happens if we set both attributes to the same coordinates
self.viewer.add_data(self.image2)
assert self.viewer.state.x_att_world is self.image2.id['Apple']
assert self.viewer.state.y_att_world is self.image2.id['Banana']
self.viewer.state.y_att_world = self.image2.id['Apple']
assert self.viewer.state.x_att_world is self.image2.id['Banana']
assert self.viewer.state.y_att_world is self.image2.id['Apple']
self.viewer.state.x_att_world = self.image2.id['Apple']
assert self.viewer.state.x_att_world is self.image2.id['Apple']
assert self.viewer.state.y_att_world is self.image2.id['Banana']
def test_duplicate_subsets(self):
# Regression test: make sure that when adding a seconda layer for the
# same dataset, we don't add the subsets all over again.
self.viewer.add_data(self.image1)
self.data_collection.new_subset_group(subset_state=self.image1.id['x'] > 1, label='A')
assert len(self.viewer.layers) == 2
self.viewer.add_data(self.image1)
assert len(self.viewer.layers) == 3
def test_aspect_subset(self):
self.viewer.add_data(self.image1)
assert self.viewer.state.aspect == 'equal'
self.viewer.state.aspect = 'auto'
self.data_collection.new_subset_group('s1', self.image1.id['x'] > 0.)
assert len(self.viewer.state.layers) == 2
assert self.viewer.state.aspect == 'auto'
self.viewer.state.aspect = 'equal'
self.data_collection.new_subset_group('s2', self.image1.id['x'] > 1.)
assert len(self.viewer.state.layers) == 3
assert self.viewer.state.aspect == 'equal'
def test_hypercube(self):
# Check defaults when we add data
self.viewer.add_data(self.hypercube)
assert combo_as_string(self.options_widget.ui.combosel_x_att_world) == 'Coordinate components:Pixel Axis 0:Pixel Axis 1:Pixel Axis 2:Pixel Axis 3'
assert combo_as_string(self.options_widget.ui.combosel_x_att_world) == 'Coordinate components:Pixel Axis 0:Pixel Axis 1:Pixel Axis 2:Pixel Axis 3'
assert self.viewer.axes.get_xlabel() == 'Pixel Axis 3'
assert self.viewer.state.x_att_world is self.hypercube.id['Pixel Axis 3']
assert self.viewer.state.x_att is self.hypercube.pixel_component_ids[3]
assert_allclose(self.viewer.state.x_min, -0.6839826839826846)
assert_allclose(self.viewer.state.x_max, +4.6839826839826846)
assert self.viewer.axes.get_ylabel() == 'Pixel Axis 2'
assert self.viewer.state.y_att_world is self.hypercube.id['Pixel Axis 2']
assert self.viewer.state.y_att is self.hypercube.pixel_component_ids[2]
assert self.viewer.state.y_min == -0.5
assert self.viewer.state.y_max == +3.5
assert not self.viewer.state.x_log
assert not self.viewer.state.y_log
assert len(self.viewer.state.layers) == 1
def test_hypercube_world(self):
# Check defaults when we add data
wcs = WCS(naxis=4)
hypercube2 = Data()
hypercube2.coords = wcs
hypercube2.add_component(np.random.random((2, 3, 4, 5)), 'a')
self.data_collection.append(hypercube2)
self.viewer.add_data(hypercube2)
def test_incompatible_subset(self):
self.viewer.add_data(self.image1)
self.data_collection.new_subset_group(subset_state=self.catalog.id['c'] > 1, label='A')
def test_invisible_subset(self):
# Regression test for a bug that caused a subset layer that started
# off as invisible to have issues when made visible. We emulate the
# initial invisible (but enabled) state by invalidating the cache.
self.viewer.add_data(self.image1)
self.data_collection.new_subset_group(subset_state=self.image1.id['x'] > 1, label='A')
self.viewer.layers[1].visible = False
self.viewer.layers[1].image_artist.invalidate_cache()
self.viewer.layers[1].redraw()
process_events()
assert not np.any(self.viewer.layers[1].image_artist._A.mask)
self.viewer.layers[1].visible = True
assert not np.any(self.viewer.layers[1].image_artist._A.mask)
def test_apply_roi_single(self):
# Regression test for a bug that caused mode.update to be called
# multiple times and resulted in all other viewers receiving many
# messages regarding subset updates (this occurred when multiple)
# datasets were present.
layer_tree = LayerTreeWidget(session=self.session)
layer_tree.set_checkable(False)
layer_tree.setup(self.data_collection)
layer_tree.bind_selection_to_edit_subset()
class Client(HubListener):
def __init__(self, *args, **kwargs):
super(Client, self).__init__(*args, **kwargs)
self.count = Counter()
def ping(self, message):
self.count[message.sender] += 1
def register_to_hub(self, hub):
hub.subscribe(self, SubsetUpdateMessage, handler=self.ping)
d1 = Data(a=[[1, 2], [3, 4]], label='d1')
d2 = Data(b=[[1, 2], [3, 4]], label='d2')
d3 = Data(c=[[1, 2], [3, 4]], label='d3')
d4 = Data(d=[[1, 2], [3, 4]], label='d4')
self.data_collection.append(d1)
self.data_collection.append(d2)
self.data_collection.append(d3)
self.data_collection.append(d4)
client = Client()
client.register_to_hub(self.hub)
self.viewer.add_data(d1)
self.viewer.add_data(d3)
roi = XRangeROI(2.5, 3.5)
self.viewer.apply_roi(roi)
for subset in client.count:
assert client.count[subset] == 1
def test_disable_incompatible(self):
# Test to make sure that image and image subset layers are disabled if
# their pixel coordinates are not compatible with the ones of the
# reference data.
self.viewer.add_data(self.image1)
self.viewer.add_data(self.image2)
assert self.viewer.state.reference_data is self.image1
self.data_collection.new_subset_group()
process_events()
assert len(self.viewer.layers) == 4
# Only the two layers associated with the reference data should be enabled
for layer_artist in self.viewer.layers:
if layer_artist.layer in (self.image1, self.image1.subsets[0]):
assert layer_artist.enabled
else:
assert not layer_artist.enabled
py1, px1 = self.image1.pixel_component_ids
py2, px2 = self.image2.pixel_component_ids
link1 = LinkSame(px1, px2)
self.data_collection.add_link(link1)
process_events()
# One link isn't enough, second dataset layers are still not enabled
for layer_artist in self.viewer.layers:
if layer_artist.layer in (self.image1, self.image1.subsets[0]):
assert layer_artist.enabled
else:
assert not layer_artist.enabled
link2 = LinkSame(py1, py2)
self.data_collection.add_link(link2)
process_events()
# All layers should now be enabled
for layer_artist in self.viewer.layers:
assert layer_artist.enabled
self.data_collection.remove_link(link2)
process_events()
# We should now be back to the original situation
for layer_artist in self.viewer.layers:
if layer_artist.layer in (self.image1, self.image1.subsets[0]):
assert layer_artist.enabled
else:
assert not layer_artist.enabled
def test_change_reference_data(self, capsys):
# Test to make sure everything works fine if we change the reference data.
self.viewer.add_data(self.image1)
self.viewer.add_data(self.image2)
assert self.viewer.state.reference_data is self.image1
assert self.viewer.state.x_att_world is self.image1.pixel_component_ids[-1]
assert self.viewer.state.y_att_world is self.image1.pixel_component_ids[-2]
assert self.viewer.state.x_att is self.image1.pixel_component_ids[-1]
assert self.viewer.state.y_att is self.image1.pixel_component_ids[-2]
self.viewer.state.reference_data = self.image2
assert self.viewer.state.reference_data is self.image2
assert self.viewer.state.x_att_world is self.image2.world_component_ids[-1]
assert self.viewer.state.y_att_world is self.image2.world_component_ids[-2]
assert self.viewer.state.x_att is self.image2.pixel_component_ids[-1]
assert self.viewer.state.y_att is self.image2.pixel_component_ids[-2]
self.viewer.state.reference_data = self.image1
assert self.viewer.state.reference_data is self.image1
assert self.viewer.state.x_att_world is self.image1.pixel_component_ids[-1]
assert self.viewer.state.y_att_world is self.image1.pixel_component_ids[-2]
assert self.viewer.state.x_att is self.image1.pixel_component_ids[-1]
assert self.viewer.state.y_att is self.image1.pixel_component_ids[-2]
# 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() == ""
@pytest.mark.parametrize('wcs', [False, True])
def test_change_reference_data_dimensionality(self, capsys, wcs):
# Regression test for a bug that caused an exception when changing
# the dimensionality of the reference data
if wcs:
first = self.image1_wcs
second = self.hypercube_wcs
else:
first = self.image1
second = self.hypercube
self.viewer.add_data(first)
self.viewer.add_data(second)
assert self.viewer.state.reference_data is first
if wcs:
assert self.viewer.state.x_att_world is first.world_component_ids[-1]
assert self.viewer.state.y_att_world is first.world_component_ids[-2]
else:
assert self.viewer.state.x_att_world is first.pixel_component_ids[-1]
assert self.viewer.state.y_att_world is first.pixel_component_ids[-2]
assert self.viewer.state.x_att is first.pixel_component_ids[-1]
assert self.viewer.state.y_att is first.pixel_component_ids[-2]
self.viewer.state.reference_data = second
assert self.viewer.state.reference_data is second
if wcs:
assert self.viewer.state.x_att_world is second.world_component_ids[-1]
assert self.viewer.state.y_att_world is second.world_component_ids[-2]
else:
assert self.viewer.state.x_att_world is second.pixel_component_ids[-1]
assert self.viewer.state.y_att_world is second.pixel_component_ids[-2]
assert self.viewer.state.x_att is second.pixel_component_ids[-1]
assert self.viewer.state.y_att is second.pixel_component_ids[-2]
self.viewer.state.reference_data = first
assert self.viewer.state.reference_data is first
if wcs:
assert self.viewer.state.x_att_world is first.world_component_ids[-1]
assert self.viewer.state.y_att_world is first.world_component_ids[-2]
else:
assert self.viewer.state.x_att_world is first.pixel_component_ids[-1]
assert self.viewer.state.y_att_world is first.pixel_component_ids[-2]
assert self.viewer.state.x_att is first.pixel_component_ids[-1]
assert self.viewer.state.y_att is first.pixel_component_ids[-2]
# 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_scatter_overlay(self):
self.viewer.add_data(self.image1)
self.viewer.add_data(self.catalog)
def test_removed_subset(self):
# Regression test for a bug in v0.11.0 that meant that if a subset
# was removed, the image viewer would then crash when changing view
# (e.g. zooming in). The bug was caused by undeleted references to
# FRBArtist due to circular references. We therefore check in this
# test how many FRBArtist objects exist.
def get_frb_artists():
mi = []
gc.collect()
for obj in gc.get_objects():
try:
if isinstance(obj, FRBArtist):
mi.append(obj)
except ReferenceError:
pass
return mi
# The viewer starts off with one FRBArtist. This is also a good test
# that other FRBArtist in other tests have been removed.
assert len(get_frb_artists()) == 1
large_image = Data(x=np.random.random((2048, 2048)))
self.data_collection.append(large_image)
# The subset group can be made from any dataset
subset_group = self.data_collection.new_subset_group(subset_state=self.image1.id['x'] > 1, label='A')
self.viewer.add_data(large_image)
# Since the dataset added has a subset, and each subset has its own
# FRBArtist, this increases the count.
assert len(get_frb_artists()) == 2
assert len(self.viewer.layers) == 2
self.data_collection.remove_subset_group(subset_group)
# Removing the subset should bring the count back to 1 again
assert len(get_frb_artists()) == 1
def test_select_previously_incompatible_layer(self):
# Regression test for a bug that caused a selection in a previously disabled
# layer to enable the layer without updating the subset view
self.viewer.add_data(self.image1)
self.viewer.add_data(self.catalog)
self.catalog.add_component([4, 5, 6], 'e')
link1 = LinkSame(self.catalog.id['c'], self.image1.pixel_component_ids[0])
link2 = LinkSame(self.catalog.id['d'], self.image1.pixel_component_ids[1])
self.data_collection.add_link(link1)
self.data_collection.add_link(link2)
self.data_collection.new_subset_group(subset_state=self.catalog.id['e'] > 4)
process_events()
assert self.viewer.layers[0].enabled # image
assert self.viewer.layers[1].enabled # scatter
assert not self.viewer.layers[2].enabled # image subset
assert self.viewer.layers[3].enabled # scatter subset
assert not self.viewer.layers[2].image_artist.get_visible()
self.data_collection.subset_groups[0].subset_state = self.catalog.id['c'] > -1
process_events()
assert self.viewer.layers[0].enabled # image
assert self.viewer.layers[1].enabled # scatter
assert self.viewer.layers[2].enabled # image subset
assert self.viewer.layers[3].enabled # scatter subset
assert self.viewer.layers[2].image_artist.get_visible()
def test_linking_and_enabling(self):
# Regression test for a bug that caused layers not not be correctly
# enabled/disabled.
self.viewer.add_data(self.image1)
self.viewer.add_data(self.catalog)
self.catalog.add_component([4, 5, 6], 'e')
self.data_collection.new_subset_group(subset_state=self.catalog.id['e'] > 4)
process_events()
assert self.viewer.layers[0].enabled # image
assert not self.viewer.layers[1].enabled # scatter
assert not self.viewer.layers[2].enabled # image subset
assert not self.viewer.layers[3].enabled # scatter subset
link1 = LinkSame(self.catalog.id['c'], self.image1.pixel_component_ids[0])
link2 = LinkSame(self.catalog.id['d'], self.image1.pixel_component_ids[1])
self.data_collection.add_link(link1)
self.data_collection.add_link(link2)
process_events()
assert self.viewer.layers[0].enabled # image
assert self.viewer.layers[1].enabled # scatter
assert not self.viewer.layers[2].enabled # image subset
assert self.viewer.layers[3].enabled # scatter subset
def test_save_aggregate_slice(self, tmpdir):
# Regression test to make sure that image viewers that include
# aggregate slice objects in the slices can be saved/restored
self.viewer.add_data(self.hypercube)
self.viewer.state.slices = AggregateSlice(slice(1, 3), 10, np.sum), 3, 0, 0
filename = tmpdir.join('session.glu').strpath
self.application.save_session(filename)
self.application.close()
app2 = GlueApplication.restore_session(filename)
viewer_state = app2.viewers[0][0].state
slices = viewer_state.slices
assert isinstance(slices[0], AggregateSlice)
assert slices[0].slice == slice(1, 3)
assert slices[0].center == 10
assert slices[0].function is np.sum
assert slices[1:] == (3, 0, 0)
app2.close()
def test_subset_cube_image(self):
# Regression test to make sure that if an image and cube are present
# in an image viewer and a subset is also present, we don't get an
# error when trying to access the subset shape
self.viewer.add_data(self.image1)
self.data_collection.new_subset_group(label='subset',
subset_state=self.image1.id['x'] > 1.5)
self.viewer.add_data(self.hypercube)
self.viewer.state.reference_data = self.hypercube
assert self.viewer.layers[1].subset_array.shape == (4, 5)
assert self.viewer.layers[3].subset_array.shape == (4, 5)
def test_preserve_slice(self):
# Regression test to make sure that when adding a second dataset to
# an image viewer, the current slice in a cube does not change.
self.viewer.add_data(self.hypercube)
self.viewer.state.slices = (1, 2, 3, 4)
self.viewer.add_data(self.image1)
assert self.viewer.state.slices == (1, 2, 3, 4)
def test_close(self):
# Regression test for a bug that caused an error related to the toolbar
# and _mpl_nav not being present when closing the viewer.
self.viewer.toolbar.active_tool = self.viewer.toolbar.tools['mpl:zoom']
self.viewer.close(warn=False)
def test_legend(self):
from matplotlib.colors import to_hex
viewer_state = self.viewer.state
self.viewer.add_data(self.image1)
self.viewer.state.legend.visible = True
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 1
assert labels[0] == 'image1'
self.data_collection.new_subset_group('test', self.image1.id['x'] > 1)
assert len(viewer_state.layers) == 2
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 2
assert labels[1] == 'test'
assert to_hex(handles[1].get_facecolor()) == viewer_state.layers[1].color
class TestSessions(object):
@pytest.mark.parametrize('protocol', [0, 1])
def test_session_back_compat(self, protocol):
filename = os.path.join(DATA, 'image_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 2
assert dc[0].label == 'data1'
assert dc[1].label == 'data2'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 3
assert viewer1.state.x_att_world is dc[0].id['World 1']
assert viewer1.state.y_att_world is dc[0].id['World 0']
assert viewer1.state.x_min < -0.5
assert viewer1.state.x_max > 1.5
assert viewer1.state.y_min <= -0.5
assert viewer1.state.y_max >= 1.5
layer_state = viewer1.state.layers[0]
assert isinstance(layer_state, ImageLayerState)
assert layer_state.visible
assert layer_state.bias == 0.5
assert layer_state.contrast == 1.0
assert layer_state.stretch == 'sqrt'
assert layer_state.percentile == 99
layer_state = viewer1.state.layers[1]
assert isinstance(layer_state, ScatterLayerState)
assert layer_state.visible
layer_state = viewer1.state.layers[2]
assert isinstance(layer_state, ImageSubsetLayerState)
assert not layer_state.visible
viewer2 = ga.viewers[0][1]
assert len(viewer2.state.layers) == 2
assert viewer2.state.x_att_world is dc[0].id['World 1']
assert viewer2.state.y_att_world is dc[0].id['World 0']
assert viewer2.state.x_min < -0.5
assert viewer2.state.x_max > 1.5
assert viewer2.state.y_min <= -0.5
assert viewer2.state.y_max >= 1.5
layer_state = viewer2.state.layers[0]
assert layer_state.visible
assert layer_state.stretch == 'arcsinh'
assert layer_state.v_min == 1
assert layer_state.v_max == 4
layer_state = viewer2.state.layers[1]
assert layer_state.visible
viewer3 = ga.viewers[0][2]
assert len(viewer3.state.layers) == 2
assert viewer3.state.x_att_world is dc[0].id['World 1']
assert viewer3.state.y_att_world is dc[0].id['World 0']
assert viewer3.state.x_min < -0.5
assert viewer3.state.x_max > 1.5
assert viewer3.state.y_min <= -0.5
assert viewer3.state.y_max >= 1.5
layer_state = viewer3.state.layers[0]
assert layer_state.visible
assert layer_state.stretch == 'linear'
assert layer_state.v_min == -2
assert layer_state.v_max == 2
layer_state = viewer3.state.layers[1]
assert layer_state.visible
ga.close()
@pytest.mark.parametrize('protocol', [0, 1])
def test_session_cube_back_compat(self, protocol):
filename = os.path.join(DATA, 'image_cube_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'array'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 1
assert viewer1.state.x_att_world is dc[0].id['World 2']
assert viewer1.state.y_att_world is dc[0].id['World 1']
assert viewer1.state.slices == [2, 0, 0, 1]
ga.close()
@pytest.mark.parametrize('protocol', [0, 1])
def test_session_rgb_back_compat(self, protocol):
filename = os.path.join(DATA, 'image_rgb_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'rgbcube'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 3
assert viewer1.state.color_mode == 'One color per layer'
layer_state = viewer1.state.layers[0]
assert layer_state.visible
assert layer_state.attribute.label == 'a'
assert layer_state.color == 'r'
layer_state = viewer1.state.layers[1]
assert not layer_state.visible
assert layer_state.attribute.label == 'c'
assert layer_state.color == 'g'
layer_state = viewer1.state.layers[2]
assert layer_state.visible
assert layer_state.attribute.label == 'b'
assert layer_state.color == 'b'
ga.close()
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() == ""
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/tests/test_regression.py 0000644 0001750 0001750 00000002726 13605357235 025505 0 ustar noahfx noahfx # Miscellaneous regression tests for the image viewer
import pytest
import numpy as np
from glue.core import Data
from glue.viewers.image.qt import ImageViewer
from glue.core.tests.util import simple_session
from glue.tests.helpers import PYSIDE2_INSTALLED # noqa
@pytest.mark.skipif('PYSIDE2_INSTALLED')
@pytest.mark.mpl_image_compare(tolerance=1, savefig_kwargs={'dpi': 50})
def test_resample_on_zoom():
# For images where the aspect ratio of pixels is fixed to be square, when
# the user zooms in, the limits of the axes are actually changed twice by
# matplotlib - a second time when the aspect ratio is enforced. So we need
# to make sure that we update the FRB artist when this is the case.
session = simple_session()
np.random.seed(12345)
data = Data(x=np.random.random((2048, 2048)), label='image')
session.data_collection.append(data)
image = ImageViewer(session=session)
image.add_data(data)
image.show()
try:
device_ratio = image.axes.figure.canvas.devicePixelRatio()
except AttributeError:
device_ratio = 1.
image.axes.figure.canvas.key_press_event('o')
image.axes.figure.canvas.button_press_event(200 * device_ratio, 200 * device_ratio, 1)
image.axes.figure.canvas.motion_notify_event(400 * device_ratio, 210 * device_ratio)
image.axes.figure.canvas.button_release_event(400 * device_ratio, 210 * device_ratio, 1)
figure = image.axes.figure
image.close()
return figure
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/data_viewer.py 0000644 0001750 0001750 00000004577 13630201003 023377 0 ustar noahfx noahfx from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.scatter.qt.layer_style_editor import ScatterLayerStyleEditor
from glue.viewers.scatter.layer_artist import ScatterLayerArtist
from glue.viewers.image.qt.layer_style_editor import ImageLayerStyleEditor
from glue.viewers.image.qt.layer_style_editor_subset import ImageLayerSubsetStyleEditor
from glue.viewers.image.layer_artist import ImageLayerArtist, ImageSubsetLayerArtist
from glue.viewers.image.qt.options_widget import ImageOptionsWidget
from glue.viewers.image.qt.mouse_mode import RoiClickAndDragMode
from glue.viewers.image.state import ImageViewerState
from glue.utils import defer_draw, decorate_all_methods
# Import the mouse mode to make sure it gets registered
from glue.viewers.image.qt.contrast_mouse_mode import ContrastBiasMode # noqa
from glue.viewers.image.qt.profile_viewer_tool import ProfileViewerTool # noqa
from glue.viewers.image.qt.pixel_selection_mode import PixelSelectionTool # noqa
from glue.viewers.image.viewer import MatplotlibImageMixin
__all__ = ['ImageViewer']
@decorate_all_methods(defer_draw)
class ImageViewer(MatplotlibImageMixin, MatplotlibDataViewer):
LABEL = '2D Image'
_default_mouse_mode_cls = RoiClickAndDragMode
_layer_style_widget_cls = {ImageLayerArtist: ImageLayerStyleEditor,
ImageSubsetLayerArtist: ImageLayerSubsetStyleEditor,
ScatterLayerArtist: ScatterLayerStyleEditor}
_state_cls = ImageViewerState
_options_cls = ImageOptionsWidget
allow_duplicate_data = True
# NOTE: _data_artist_cls and _subset_artist_cls are not defined - instead
# we override get_data_layer_artist and get_subset_layer_artist for
# more advanced logic.
tools = ['select:rectangle', 'select:xrange',
'select:yrange', 'select:circle',
'select:polygon', 'image:point_selection', 'image:contrast_bias',
'profile-viewer']
def __init__(self, session, parent=None, state=None):
MatplotlibDataViewer.__init__(self, session, wcs=True, parent=parent, state=state)
MatplotlibImageMixin.setup_callbacks(self)
def closeEvent(self, *args):
super(ImageViewer, self).closeEvent(*args)
if self.axes._composite_image is not None:
self.axes._composite_image.remove()
self.axes._composite_image = None
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/options_widget.ui 0000644 0001750 0001750 00000027334 13661230662 024145 0 ustar noahfx noahfx
Widget
0
0
288
238
2D Image
5
5
5
5
5
-
0
General
10
10
10
10
10
5
-
75
true
mode
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
QComboBox::AdjustToMinimumContentsLength
-
QComboBox::AdjustToMinimumContentsLength
-
Qt::Horizontal
-
Qt::Horizontal
40
5
-
75
true
reference
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
QComboBox::AdjustToMinimumContentsLength
-
75
true
aspect
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
x axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
y axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
QComboBox::AdjustToMinimumContentsLength
-
QComboBox::AdjustToMinimumContentsLength
-
-
Qt::Vertical
20
40
Limits
10
10
10
10
10
5
-
padding: 0px
⇄
-
75
true
y axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
40
5
-
-
-
Qt::Vertical
20
40
-
-
-
75
true
x axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
padding: 0px
⇄
label_2
valuetext_x_min
button_flip_x
valuetext_x_max
label_2
valuetext_y_min
button_flip_y
valuetext_y_max
verticalSpacer_3
horizontalSpacer
Axes
5
5
5
5
-
Legend
5
5
5
5
-
AxesEditorWidget
QWidget
glue.viewers.matplotlib.qt.axes_editor
LegendEditorWidget
QWidget
glue.viewers.matplotlib.qt.legend_editor
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/layer_style_editor_subset.ui 0000644 0001750 0001750 00000004747 13502206677 026404 0 ustar noahfx noahfx
Form
0
0
234
55
Form
5
5
-
0
0
-
100
Qt::Horizontal
-
75
true
transparency
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
color
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Vertical
20
40
QColorBox
QLabel
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/slice_widget.py 0000644 0001750 0001750 00000012313 13752534424 023557 0 ustar noahfx noahfx import numpy as np
from glue.core.coordinates import LegacyCoordinates
from glue.core.coordinate_helpers import dependent_axes, world_axis
from glue.viewers.common.qt.data_slice_widget import SliceWidget
from glue.viewers.image.state import AggregateSlice
from glue.utils.decorators import avoid_circular
__all__ = ['MultiSliceWidgetHelper']
class MultiSliceWidgetHelper(object):
def __init__(self, viewer_state=None, layout=None):
self.viewer_state = viewer_state
self.layout = layout
self.layout.setSpacing(4)
self.layout.setContentsMargins(0, 3, 0, 3)
self.viewer_state.add_callback('x_att', self.sync_sliders_from_state)
self.viewer_state.add_callback('y_att', self.sync_sliders_from_state)
self.viewer_state.add_callback('slices', self.sync_sliders_from_state)
self.viewer_state.add_callback('reference_data', self.sync_sliders_from_state)
self._sliders = []
self._reference_data = None
self._x_att = None
self._y_att = None
self.sync_sliders_from_state()
@property
def data(self):
return self.viewer_state.reference_data
def _clear(self):
for _ in range(self.layout.count()):
self.layout.takeAt(0)
for s in self._sliders:
if s is not None:
s.close()
self._sliders = []
@avoid_circular
def sync_state_from_sliders(self, *args):
slices = []
for i, slider in enumerate(self._sliders):
if slider is not None:
slices.append(slider.state.slice_center)
else:
slices.append(self.viewer_state.slices[i])
self.viewer_state.slices = tuple(slices)
@avoid_circular
def sync_sliders_from_state(self, *args):
if self.data is None or self.viewer_state.x_att is None or self.viewer_state.y_att is None:
return
if self.viewer_state.x_att is self.viewer_state.y_att:
return
# Update sliders if needed
if (self.viewer_state.reference_data is not self._reference_data or
self.viewer_state.x_att is not self._x_att or
self.viewer_state.y_att is not self._y_att):
self._reference_data = self.viewer_state.reference_data
self._x_att = self.viewer_state.x_att
self._y_att = self.viewer_state.y_att
self._clear()
for i in range(self.data.ndim):
if i == self.viewer_state.x_att.axis or i == self.viewer_state.y_att.axis:
self._sliders.append(None)
continue
# TODO: For now we simply pass a single set of world coordinates,
# but we will need to generalize this in future. We deliberately
# check the type of data.coords here since we want to treat
# subclasses differently.
if getattr(self.data, 'coords') is not None and type(self.data.coords) != LegacyCoordinates:
world_axis_index = self.data.ndim - 1 - i
world = world_axis(self.data.coords, self.data,
pixel_axis=world_axis_index,
world_axis=world_axis_index)
world_unit = self.data.coords.world_axis_units[world_axis_index]
world_warning = len(dependent_axes(self.data.coords, i)) > 1
world_label = self.data.world_component_ids[i].label
else:
world = None
world_unit = None
world_warning = False
world_label = self.data.pixel_component_ids[i].label
slider = SliceWidget(world_label,
hi=self.data.shape[i] - 1, world=world,
world_unit=world_unit, world_warning=world_warning)
self.slider_state = slider.state
self.slider_state.add_callback('slice_center', self.sync_state_from_sliders)
self._sliders.append(slider)
self.layout.addWidget(slider)
for i in range(self.data.ndim):
if self._sliders[i] is not None:
if isinstance(self.viewer_state.slices[i], AggregateSlice):
self._sliders[i].state.slice_center = self.viewer_state.slices[i].center
else:
self._sliders[i].state.slice_center = self.viewer_state.slices[i]
if __name__ == "__main__":
from glue.core import Data
from glue.utils.qt import get_qapp
from echo import CallbackProperty
from glue.core.state_objects import State
app = get_qapp()
class FakeViewerState(State):
x_att = CallbackProperty()
y_att = CallbackProperty()
reference_data = CallbackProperty()
slices = CallbackProperty()
viewer_state = FakeViewerState()
data = Data(x=np.random.random((3, 50, 20, 5, 3)))
viewer_state.reference_data = data
viewer_state.x_att = data.pixel_component_ids[0]
viewer_state.y_att = data.pixel_component_ids[3]
viewer_state.slices = [0] * 5
widget = MultiSliceWidgetHelper(viewer_state)
widget.show()
app.exec_()
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/__init__.py 0000644 0001750 0001750 00000000304 13630201003 022624 0 ustar noahfx noahfx from .data_viewer import ImageViewer # noqa
from .standalone_image_viewer import StandaloneImageViewer # noqa
def setup():
from glue.config import qt_client
qt_client.add(ImageViewer)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/options_widget.py 0000644 0001750 0001750 00000003125 13752534424 024154 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
from glue.viewers.image.qt.slice_widget import MultiSliceWidgetHelper
from glue.viewers.matplotlib.state import MatplotlibDataViewerState
__all__ = ['ImageOptionsWidget']
class ImageOptionsWidget(QtWidgets.QWidget):
def __init__(self, viewer_state, session, parent=None):
super(ImageOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self._connections = autoconnect_callbacks_to_qt(viewer_state, self.ui)
self._connections_axes = autoconnect_callbacks_to_qt(viewer_state, self.ui.axes_editor.ui)
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections_legend = autoconnect_callbacks_to_qt(viewer_state.legend, self.ui.legend_editor.ui, connect_kwargs)
self.viewer_state = viewer_state
self.slice_helper = MultiSliceWidgetHelper(viewer_state=self.viewer_state,
layout=self.ui.layout_slices)
self.session = session
self.ui.axes_editor.button_apply_all.clicked.connect(self._apply_all_viewers)
def _apply_all_viewers(self):
for tab in self.session.application.viewers:
for viewer in tab:
if isinstance(viewer.state, MatplotlibDataViewerState):
viewer.state.update_axes_settings_from(self.viewer_state)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/mouse_mode.py 0000644 0001750 0001750 00000006070 13636642246 023257 0 ustar noahfx noahfx from qtpy.QtGui import QCursor
from qtpy.QtWidgets import QMenu, QAction
from glue.core.subset import RoiSubsetState
from glue.core.roi import MplPolygonalROI
from glue.core.edit_subset_mode import ReplaceMode
from glue.viewers.matplotlib.mouse_mode import MouseMode
from glue.viewers.image.layer_artist import ImageSubsetLayerArtist
__all__ = ['RoiClickAndDragMode']
_MPL_LEFT_CLICK = 1
_MPL_RIGHT_CLICK = 3
class RoiClickAndDragMode(MouseMode):
"""
A MouseMode that enables clicking and dragging of existing ROIs.
"""
def __init__(self, viewer, **kwargs):
super(RoiClickAndDragMode, self).__init__(viewer, **kwargs)
self._viewer = viewer
self._dc = viewer.state.data_collection
self._edit_subset_mode = viewer.session.edit_subset_mode
self._roi = None
self._subset = None
self._selected = False
def _select_roi(self, roi, index, event):
self._roi = MplPolygonalROI(self._axes, roi=roi)
self._roi.start_selection(event, scrubbing=True)
self._edit_subset_mode.edit_subset = [self._dc.subset_groups[index]]
def _deselect_roi(self, event):
self._edit_subset_mode.edit_subset = []
if self._roi:
self._roi = None
self._subset = None
def _display_roi_context_menu(self, roi_index):
def delete_roi(event):
self._dc.remove_subset_group(self._dc.subset_groups[roi_index])
context_menu = QMenu()
action = QAction("Delete ROI", context_menu)
action.triggered.connect(delete_roi)
context_menu.addAction(action)
pos = self._viewer.mapToParent(QCursor().pos())
context_menu.exec_(pos)
def press(self, event):
# Ignore button presses outside the data viewer canvas
if event.xdata is None or event.ydata is None:
return
x, y = (int(event.xdata + 0.5), int(event.ydata + 0.5))
roi_index = 0
for layer in self._viewer.layers:
if not isinstance(layer, ImageSubsetLayerArtist):
continue
subset_state = layer.state.layer.subset_state
if layer.visible and isinstance(subset_state, RoiSubsetState):
if subset_state.roi.contains(x, y):
if event.button == _MPL_LEFT_CLICK:
self._select_roi(subset_state.roi, roi_index, event)
self._subset = layer.state.layer
elif event.button == _MPL_RIGHT_CLICK:
self._display_roi_context_menu(roi_index)
self._selected = True
break
roi_index += 1
else:
self._selected = False
self._deselect_roi(event)
def move(self, event):
if self._roi is None or not self._selected:
return
self._roi.update_selection(event)
def release(self, event):
if self._roi:
self._viewer.apply_roi(self._roi.roi(), override_mode=ReplaceMode)
self._roi.finalize_selection(event)
self._selected = False
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/pixel_selection_mode.py 0000644 0001750 0001750 00000003674 13605357235 025321 0 ustar noahfx noahfx from glue.config import viewer_tool
from glue.core.command import ApplySubsetState
from glue.core.edit_subset_mode import ReplaceMode
from glue.viewers.matplotlib.toolbar_mode import ToolbarModeBase
from glue.viewers.image.pixel_selection_subset_state import PixelSubsetState
__all__ = ['PixelSelectionTool']
@viewer_tool
class PixelSelectionTool(ToolbarModeBase):
"""
Selects pixel under mouse cursor.
"""
icon = "glue_crosshair"
tool_id = 'image:point_selection'
action_text = 'Pixel'
tool_tip = 'Select a single pixel based on mouse location'
status_tip = 'CLICK to select a point, CLICK and DRAG to update the selection in real time'
_pressed = False
def __init__(self, *args, **kwargs):
super(PixelSelectionTool, self).__init__(*args, **kwargs)
self._move_callback = self._select_pixel
self._press_callback = self._on_press
self._release_callback = self._on_release
def _on_press(self, mode):
self._pressed = True
self.viewer.session.edit_subset_mode.mode = ReplaceMode
self._select_pixel(mode)
def _on_release(self, mode):
self._pressed = False
def _select_pixel(self, mode):
"""
Select a pixel
"""
if not self._pressed:
return
x, y = self._event_xdata, self._event_ydata
if x is None or y is None:
return None
x = int(round(x))
y = int(round(y))
slices = [slice(None)] * self.viewer.state.reference_data.ndim
slices[self.viewer.state.x_att.axis] = slice(x, x + 1)
slices[self.viewer.state.y_att.axis] = slice(y, y + 1)
subset_state = PixelSubsetState(self.viewer.state.reference_data, slices)
cmd = ApplySubsetState(data_collection=self.viewer._data,
subset_state=subset_state,
override_mode=None)
self.viewer._session.command_stack.do(cmd)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/standalone_image_viewer.py 0000644 0001750 0001750 00000012220 13630201003 025740 0 ustar noahfx noahfx import numpy as np
from qtpy import QtCore, QtWidgets
from glue.config import colormaps
from glue.viewers.common.qt.toolbar import BasicToolbar
from glue.viewers.matplotlib.qt.widget import MplWidget
from glue.viewers.image.composite_array import CompositeArray
from glue.external.modest_image import imshow
from glue.utils import defer_draw
from glue.viewers.matplotlib.mpl_axes import init_mpl
# Import the mouse mode to make sure it gets registered
from glue.viewers.image.qt.contrast_mouse_mode import ContrastBiasMode # noqa
__all__ = ['StandaloneImageViewer']
class StandaloneImageViewer(QtWidgets.QMainWindow):
"""
A simplified image viewer, without any brushing or linking,
but with the ability to adjust contrast and resample.
"""
window_closed = QtCore.Signal()
_toolbar_cls = BasicToolbar
tools = ['image:contrast', 'image:colormap']
def __init__(self, image=None, wcs=None, parent=None, **kwargs):
"""
:param image: Image to display (2D numpy array)
:param parent: Parent widget (optional)
:param kwargs: Extra keywords to pass to imshow
"""
super(StandaloneImageViewer, self).__init__(parent)
self.central_widget = MplWidget()
self.setCentralWidget(self.central_widget)
self._setup_axes()
self._composite = CompositeArray()
self._composite.allocate('image')
self._im = None
self.initialize_toolbar()
if image is not None:
self.set_image(image=image, wcs=wcs, **kwargs)
def _setup_axes(self):
_, self._axes = init_mpl(self.central_widget.canvas.fig, axes=None, wcs=True)
self._axes.set_aspect('equal', adjustable='datalim')
@defer_draw
def set_image(self, image=None, wcs=None, **kwargs):
"""
Update the image shown in the widget
"""
if self._im is not None:
self._im.remove()
self._im = None
kwargs.setdefault('origin', 'upper')
self._composite.set('image', array=image, color=colormaps.members[0][1])
self._im = imshow(self._axes, self._composite, **kwargs)
self._im_array = image
self._set_norm(self._contrast_mode)
if 'extent' in kwargs:
self.axes.set_xlim(kwargs['extent'][:2])
self.axes.set_ylim(kwargs['extent'][2:])
else:
ny, nx = image.shape
self.axes.set_xlim(-0.5, nx - 0.5)
self.axes.set_ylim(-0.5, ny - 0.5)
# FIXME: for a reason I don't quite understand, dataLim doesn't
# get updated immediately here, which means that there are then
# issues in the first draw of the image (the limits are such that
# only part of the image is shown). We just set dataLim manually
# to avoid this issue. This is also done in ImageViewer.
self.axes.dataLim.intervalx = self.axes.get_xlim()
self.axes.dataLim.intervaly = self.axes.get_ylim()
self._redraw()
@property
def axes(self):
"""
The Matplotlib axes object for this figure
"""
return self._axes
def show(self):
super(StandaloneImageViewer, self).show()
self._redraw()
def _redraw(self):
self.central_widget.canvas.draw_idle()
def set_cmap(self, cmap):
self._composite.set('image', color=cmap)
self._im.invalidate_cache()
self._redraw()
def mdi_wrap(self):
"""
Embed this widget in a GlueMdiSubWindow
"""
from glue.app.qt.mdi_area import GlueMdiSubWindow
sub = GlueMdiSubWindow()
sub.setWidget(self)
self.destroyed.connect(sub.close)
self.window_closed.connect(sub.close)
sub.resize(self.size())
self._mdi_wrapper = sub
return sub
def closeEvent(self, event):
if self._im is not None:
self._im.remove()
self._im = None
self.window_closed.emit()
return super(StandaloneImageViewer, self).closeEvent(event)
def _set_norm(self, mode):
"""
Use the `ContrastMouseMode` to adjust the transfer function
"""
pmin, pmax = mode.get_clip_percentile()
if pmin is None:
clim = mode.get_vmin_vmax()
else:
clim = (np.nanpercentile(self._im_array, pmin),
np.nanpercentile(self._im_array, pmax))
stretch = mode.stretch
self._composite.set('image', clim=clim, stretch=stretch,
bias=mode.bias, contrast=mode.contrast)
self._im.invalidate_cache()
self._redraw()
def initialize_toolbar(self):
from glue.config import viewer_tool
self.toolbar = self._toolbar_cls(self)
for tool_id in self.tools:
mode_cls = viewer_tool.members[tool_id]
if tool_id == 'image:contrast':
mode = mode_cls(self, move_callback=self._set_norm)
self._contrast_mode = mode
else:
mode = mode_cls(self)
self.toolbar.add_tool(mode)
self.addToolBar(self.toolbar)
def set_status(self, message):
sb = self.statusBar()
sb.showMessage(message)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/layer_style_editor.ui 0000644 0001750 0001750 00000017702 13502206677 025012 0 ustar noahfx noahfx
Form
0
0
292
197
Form
5
5
5
5
10
5
-
QComboBox::AdjustToMinimumContentsLength
-
75
true
attribute
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
limits
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Vertical
20
40
-
10
-
-
80
0
QComboBox::AdjustToMinimumContentsLength
false
-
0
0
-
50
0
100
Qt::Horizontal
-
Sync
true
-
2
-
-
padding: 0px
⇄
-
-
50
0
QComboBox::AdjustToMinimumContentsLength
-
50
0
QComboBox::AdjustToMinimumContentsLength
-
10
-
50
0
1000
Qt::Horizontal
-
50
0
1000
Qt::Horizontal
-
Reset
-
75
true
contrast/bias
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
color/opacity
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
40
5
QColorBox
QLabel
QColormapCombo
QComboBox
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/contrast_mouse_mode.py 0000644 0001750 0001750 00000002312 13657331513 025162 0 ustar noahfx noahfx # New contrast/bias mode that operates on viewers with state objects
from echo import delay_callback
from glue.config import viewer_tool
from glue.viewers.matplotlib.toolbar_mode import ToolbarModeBase
@viewer_tool
class ContrastBiasMode(ToolbarModeBase):
"""
Uses right mouse button drags to set bias and contrast, DS9-style. The
horizontal position of the mouse sets the bias, the vertical position sets
the contrast.
"""
icon = 'glue_contrast'
tool_id = 'image:contrast_bias'
action_text = 'Contrast/Bias'
tool_tip = 'Adjust the bias/contrast'
status_tip = ('CLICK and DRAG on image from left to right to adjust '
'bias and up and down to adjust contrast')
def move(self, event):
"""
Update bias and contrast on Right Mouse button drag.
"""
if event.button not in (1, 3):
return
x, y = self.viewer.axes.transAxes.inverted().transform((event.x, event.y))
state = self.viewer.selected_layer.state
with delay_callback(state, 'bias', 'contrast'):
state.bias = -(x * 2 - 1.5)
state.contrast = 10. ** (y * 2 - 1)
super(ContrastBiasMode, self).move(event)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/profile_viewer_tool.py 0000644 0001750 0001750 00000006534 13630201003 025156 0 ustar noahfx noahfx from glue.config import viewer_tool
from glue.viewers.common.tool import Tool
from glue.core.qt.dialogs import info, warn
from glue.core.component_id import PixelComponentID
@viewer_tool
class ProfileViewerTool(Tool):
icon = 'glue_spectrum'
tool_id = 'profile-viewer'
@property
def profile_viewers_exist(self):
from glue.viewers.profile.qt import ProfileViewer
for tab in self.viewer.session.application.viewers:
for viewer in tab:
if isinstance(viewer, ProfileViewer):
return True
return False
def activate(self):
if self.profile_viewers_exist:
proceed = warn('A profile viewer was already created',
'Do you really want to create a new one?',
default='Cancel', setting='show_warn_profile_duplicate')
if not proceed:
return
else:
proceed = info('Creating a profile viewer',
'Note: profiles are '
'computed from datasets and subsets collapsed along all but one '
'dimension. To view the profile of part of the data, once you '
'click OK you can draw and update a subset in the current '
'image viewer and the profile will update accordingly.', setting='show_info_profile_open')
if not proceed:
return
from glue.viewers.profile.qt import ProfileViewer
profile_viewer = self.viewer.session.application.new_data_viewer(ProfileViewer)
any_added = False
for data in self.viewer.session.data_collection:
if data in self.viewer._layer_artist_container:
result = profile_viewer.add_data(data)
any_added = any_added or result
if not any_added:
profile_viewer.close()
return
# If the reference data for the current image viewer is in the profile
# viewer, we make sure that it is used as the reference data there too
if self.viewer.state.reference_data in profile_viewer._layer_artist_container:
profile_viewer.state.reference_data = self.viewer.state.reference_data
# We now pick an attribute in the profile viewer that is one of the ones
# with a slider in the image viewer. Note that the attribute viewer may
# be a pixel attribute or world attribute depending on what information
# is available in the coordinates, so we need to be careful about that.
x_att = profile_viewer.state.x_att
reference_data = self.viewer.state.reference_data
if isinstance(profile_viewer.state.x_att, PixelComponentID):
for att in reference_data.pixel_component_ids:
if att is not self.viewer.state.x_att and att is not self.viewer.state.y_att:
if att is not profile_viewer.state.x_att:
profile_viewer.state.x_att = att
else:
for att in reference_data.world_component_ids:
if att is not self.viewer.state.x_att_world and att is not self.viewer.state.y_att_world:
if att is not profile_viewer.state.x_att:
profile_viewer.state.x_att = att
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/layer_style_editor_subset.py 0000644 0001750 0001750 00000001105 13657331513 026377 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui
class ImageLayerSubsetStyleEditor(QtWidgets.QWidget):
def __init__(self, layer, parent=None):
super(ImageLayerSubsetStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor_subset.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/qt/layer_style_editor.py 0000644 0001750 0001750 00000002305 13657331513 025015 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui
class ImageLayerStyleEditor(QtWidgets.QWidget):
def __init__(self, layer, parent=None):
super(ImageLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1)),
'contrast': dict(value_range=(0.1, 10), log=True),
'bias': dict(value_range=(1.5, -0.5))}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
layer._viewer_state.add_callback('color_mode', self._update_color_mode)
self._update_color_mode(layer._viewer_state.color_mode)
self.ui.bool_global_sync.setToolTip('Whether to sync the color and transparency with other viewers')
def _update_color_mode(self, color_mode):
if color_mode == 'Colormaps':
self.ui.color_color.hide()
self.ui.combodata_cmap.show()
else:
self.ui.color_color.show()
self.ui.combodata_cmap.hide()
glueviz-1.0.1+dfsg.orig/glue/viewers/image/python_export.py 0000644 0001750 0001750 00000007735 13661230662 023423 0 ustar noahfx noahfx from glue.viewers.common.python_export import code, serialize_options
def python_export_image_layer(layer, *args):
if not layer.enabled or not layer.visible:
return [], None
script = ""
imports = ["from glue.viewers.image.state import get_sliced_data_maker"]
imports += ["import matplotlib.patches as mpatches"]
slices, agg_func, transpose = layer._viewer_state.numpy_slice_aggregation_transpose
# TODO: implement aggregation, ignore for now
script += "# Define a function that will get a fixed resolution buffer\n"
options = {'data': code('layer_data'),
'x_axis': layer._viewer_state.x_att.axis,
'y_axis': layer._viewer_state.y_att.axis,
'slices': slices,
'target_cid': code("layer_data.id['{0}']".format(layer.state.attribute))}
if transpose:
options['transpose'] = True
script += "array_maker = get_sliced_data_maker({0})\n\n".format(serialize_options(options))
script += "composite.allocate('{0}')\n".format(layer.uuid)
if layer._viewer_state.color_mode == 'Colormaps':
color = code('plt.cm.' + layer.state.cmap.name)
else:
color = layer.state.color
options = dict(array=code('array_maker'),
clim=(layer.state.v_min, layer.state.v_max),
visible=layer.state.visible,
zorder=layer.state.zorder,
color=color,
contrast=layer.state.contrast,
bias=layer.state.bias,
alpha=layer.state.alpha,
stretch=layer.state.stretch)
script += "composite.set('{0}', {1})\n".format(layer.uuid, serialize_options(options))
if layer._viewer_state.color_mode == 'Colormaps':
imports += ["from glue.utils.matplotlib import ColormapPatchHandler"]
script += "handle = mpatches.Patch(color='{0}')\n".format(layer.state.color)
script += "handler = ColormapPatchHandler(" + code('plt.cm.' + layer.state.cmap.name) + ")\n"
script += "legend_handles.append(handle)\n"
script += "legend_handler_dict[handle] = handler\n"
script += "legend_labels.append(layer_data.label)\n"
else:
options = dict(color=layer.state.color,
alpha=layer.state.alpha)
script += "handle = mpatches.Patch({0})\n".format(serialize_options(options))
script += "legend_handles.append(handle)\n"
script += "legend_labels.append(layer_data.label)\n"
script += "\n"
return imports, script.strip()
def python_export_image_subset_layer(layer, *args):
if not layer.enabled or not layer.visible:
return [], None
script = ""
imports = ["from glue.viewers.image.state import get_sliced_data_maker"]
slices, agg_func, transpose = layer._viewer_state.numpy_slice_aggregation_transpose
# TODO: implement aggregation, ignore for now
script += "# Define a function that will get a fixed resolution buffer of the mask\n"
options = {'data': code('layer_data'),
'x_axis': layer._viewer_state.x_att.axis,
'y_axis': layer._viewer_state.y_att.axis,
'slices': slices}
if transpose:
options['transpose'] = True
script += "array_maker = get_sliced_data_maker({0})\n\n".format(serialize_options(options))
script += "\n\n"
options = dict(origin='lower', interpolation='nearest', color=layer.state.color,
vmin=0, vmax=1, aspect=layer._viewer_state.aspect,
zorder=layer.state.zorder, alpha=layer.state.alpha)
script += "imshow(ax, {0}, {1})\n".format(code('array_maker'), serialize_options(options))
# legend
options = dict(color=layer.state.color,
alpha=layer.state.alpha)
script += "handle = mpatches.Patch({0})\n".format(serialize_options(options))
script += "legend_handles.append(handle)\n"
script += "legend_labels.append(layer_data.label)\n"
script += "\n"
return imports, script.strip()
glueviz-1.0.1+dfsg.orig/glue/viewers/image/frb_artist.py 0000644 0001750 0001750 00000004277 13605357235 022642 0 ustar noahfx noahfx """
Matplotlib artist for fixed resolution buffers.
"""
from mpl_scatter_density.base_image_artist import BaseImageArtist
import numpy as np
from glue.utils import color2rgb
class FRBArtist(BaseImageArtist):
def __init__(self, ax, **kwargs):
self._array_maker = None
super(FRBArtist, self).__init__(ax, update_while_panning=False,
array_func=self.array_func_wrapper,
**kwargs)
def array_func_wrapper(self, bins=None, range=None):
if self._array_maker is None:
return np.array([[np.nan]])
else:
ny, nx = bins
(ymin, ymax), (xmin, xmax) = range
bounds = [(ymin, ymax, ny), (xmin, xmax, nx)]
array = self._array_maker(bounds)
if array is None:
return np.array([[np.nan]])
else:
return array
def set_array_maker(self, array_maker):
self._array_maker = array_maker
def invalidate_cache(self):
self.stale = True
self.set_visible(True)
def imshow(axes, array_maker, aspect=None, vmin=None, vmax=None, color=None, **kwargs):
"""
Similar to matplotlib's imshow command, but produces a FRBArtist
"""
axes.set_aspect(aspect)
im = FRBArtist(axes, **kwargs)
if color:
def wrapper(bounds=None):
# Get original array
mask = array_maker(bounds=bounds)
# Convert to RGBA array"
r, g, b = color2rgb(color)
mask = np.dstack((r * mask, g * mask, b * mask, mask * .5))
mask = (255 * mask).astype(np.uint8)
return mask
im.set_array_maker(wrapper)
else:
im.set_array_maker(array_maker)
axes._set_artist_props(im)
if im.get_clip_path() is None:
# image does not already have clipping set, clip to axes patch
im.set_clip_path(axes.patch)
if vmin is not None or vmax is not None:
im.set_clim(vmin, vmax)
axes.images.append(im)
def remove(h):
axes.images.remove(h)
# The following is needed for Matplotlib's .remove() method to work
im._remove_method = remove
return im
glueviz-1.0.1+dfsg.orig/glue/viewers/image/state.py 0000644 0001750 0001750 00000057225 13752534424 021624 0 ustar noahfx noahfx import uuid
from collections import defaultdict
from glue.core import BaseData
from glue.config import colormaps
from glue.viewers.matplotlib.state import (MatplotlibDataViewerState,
MatplotlibLayerState,
DeferredDrawCallbackProperty as DDCProperty,
DeferredDrawSelectionCallbackProperty as DDSCProperty)
from glue.core.state_objects import StateAttributeLimitsHelper
from glue.utils import defer_draw, view_shape
from echo import delay_callback
from glue.core.data_combo_helper import ManualDataComboHelper, ComponentIDComboHelper
from glue.core.exceptions import IncompatibleDataException
__all__ = ['ImageViewerState', 'ImageLayerState', 'ImageSubsetLayerState', 'AggregateSlice']
def get_sliced_data_maker(x_axis=None, y_axis=None, slices=None, data=None,
target_cid=None, reference_data=None, transpose=False):
"""
Convenience function for use in exported Python scripts.
"""
if reference_data is None:
reference_data = data
def get_array(bounds=None):
full_bounds = list(slices)
full_bounds[y_axis] = bounds[0]
full_bounds[x_axis] = bounds[1]
if isinstance(data, BaseData):
array = data.compute_fixed_resolution_buffer(full_bounds, target_data=reference_data,
target_cid=target_cid, broadcast=False)
else:
array = data.data.compute_fixed_resolution_buffer(full_bounds, target_data=reference_data,
subset_state=data.subset_state, broadcast=False)
if transpose:
array = array.transpose()
return array
return get_array
class AggregateSlice(object):
def __init__(self, slice=None, center=None, function=None):
self.slice = slice
self.center = center
self.function = function
def __gluestate__(self, context):
state = dict(slice=context.do(self.slice),
center=self.center,
function=context.do(self.function))
return state
@classmethod
def __setgluestate__(cls, rec, context):
return cls(slice=context.object(rec['slice']),
center=rec['center'],
function=context.object(rec['function']))
class ImageViewerState(MatplotlibDataViewerState):
"""
A state class that includes all the attributes for an image viewer.
"""
x_att = DDCProperty(docstring='The component ID giving the pixel component '
'shown on the x axis')
y_att = DDCProperty(docstring='The component ID giving the pixel component '
'shown on the y axis')
x_att_world = DDSCProperty(docstring='The component ID giving the world component '
'shown on the x axis', default_index=-1)
y_att_world = DDSCProperty(docstring='The component ID giving the world component '
'shown on the y axis', default_index=-2)
aspect = DDSCProperty(0, docstring='Whether to enforce square pixels (``equal``) '
'or fill the axes (``auto``)')
reference_data = DDSCProperty(docstring='The dataset that is used to define the '
'available pixel/world components, and '
'which defines the coordinate frame in '
'which the images are shown')
slices = DDCProperty(docstring='The current slice along all dimensions')
color_mode = DDSCProperty(0, docstring='Whether each layer can have '
'its own colormap (``Colormaps``) or '
'whether each layer is assigned '
'a single color (``One color per layer``)')
dpi = DDCProperty(72, docstring='The resolution (in dots per inch) of density maps, if present')
def __init__(self, **kwargs):
super(ImageViewerState, self).__init__()
self.limits_cache = {}
# NOTE: we don't need to use StateAttributeLimitsHelper here because
# we can simply call reset_limits below when x/y attributes change.
# Using StateAttributeLimitsHelper makes things a lot slower.
self.ref_data_helper = ManualDataComboHelper(self, 'reference_data')
self.xw_att_helper = ComponentIDComboHelper(self, 'x_att_world',
numeric=False, datetime=False, categorical=False)
self.yw_att_helper = ComponentIDComboHelper(self, 'y_att_world',
numeric=False, datetime=False, categorical=False)
self.add_callback('reference_data', self._reference_data_changed, priority=1000)
self.add_callback('layers', self._layers_changed, priority=1000)
self.add_callback('x_att', self._on_xatt_change, priority=500)
self.add_callback('y_att', self._on_yatt_change, priority=500)
self.add_callback('x_att_world', self._on_xatt_world_change, priority=1000)
self.add_callback('y_att_world', self._on_yatt_world_change, priority=1000)
aspect_display = {'equal': 'Square Pixels', 'auto': 'Automatic'}
ImageViewerState.aspect.set_choices(self, ['equal', 'auto'])
ImageViewerState.aspect.set_display_func(self, aspect_display.get)
ImageViewerState.color_mode.set_choices(self, ['Colormaps', 'One color per layer'])
self.update_from_dict(kwargs)
def reset_limits(self):
if self.reference_data is None or self.x_att is None or self.y_att is None:
return
nx = self.reference_data.shape[self.x_att.axis]
ny = self.reference_data.shape[self.y_att.axis]
with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'):
self.x_min = -0.5
self.x_max = nx - 0.5
self.y_min = -0.5
self.y_max = ny - 0.5
# We need to adjust the limits in here to avoid triggering all
# the update events then changing the limits again.
self._adjust_limits_aspect()
@property
def _display_world(self):
return getattr(self.reference_data, 'coords', None) is not None
def _reference_data_changed(self, *args):
# This signal can get emitted if just the choices but not the actual
# reference data change, so we check here that the reference data has
# actually changed
if self.reference_data is not getattr(self, '_last_reference_data', None):
self._last_reference_data = self.reference_data
# Note that we deliberately use nested delay_callback here, because
# we want to make sure that x_att_world and y_att_world both get
# updated first, then x_att and y_att can be changed, before
# subsequent events are fired.
with delay_callback(self, 'x_att', 'y_att'):
with delay_callback(self, 'x_att_world', 'y_att_world', 'slices'):
if self._display_world:
self.xw_att_helper.pixel_coord = False
self.yw_att_helper.pixel_coord = False
self.xw_att_helper.world_coord = True
self.yw_att_helper.world_coord = True
else:
self.xw_att_helper.pixel_coord = True
self.yw_att_helper.pixel_coord = True
self.xw_att_helper.world_coord = False
self.yw_att_helper.world_coord = False
self._update_combo_att()
self._set_default_slices()
# We need to make sure that we update x_att and y_att
# at the same time before any other callbacks get called,
# so we do this here manually.
self._on_xatt_world_change()
self._on_yatt_world_change()
def _layers_changed(self, *args):
# The layers callback gets executed if anything in the layers changes,
# but we only care about whether the actual set of 'layer' attributes
# for all layers change.
layers_data = self.layers_data
layers_data_cache = getattr(self, '_layers_data_cache', [])
if layers_data == layers_data_cache:
return
self._update_combo_ref_data()
self._set_reference_data()
self._update_syncing()
self._layers_data_cache = layers_data
def _update_syncing(self):
# If there are multiple layers for a given dataset, we disable the
# syncing by default.
layer_state_by_data = defaultdict(list)
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer_state_by_data[layer_state.layer].append(layer_state)
for data, layer_states in layer_state_by_data.items():
if len(layer_states) > 1:
for layer_state in layer_states:
# Scatter layers don't have global_sync so we need to be
# careful here and make sure we return a default value
if getattr(layer_state, 'global_sync', False):
layer_state.global_sync = False
def _update_combo_ref_data(self):
self.ref_data_helper.set_multiple_data(self.layers_data)
def _update_combo_att(self):
with delay_callback(self, 'x_att_world', 'y_att_world'):
if self.reference_data is None:
self.xw_att_helper.set_multiple_data([])
self.yw_att_helper.set_multiple_data([])
else:
self.xw_att_helper.set_multiple_data([self.reference_data])
self.yw_att_helper.set_multiple_data([self.reference_data])
def _update_priority(self, name):
if name == 'layers':
return 3
elif name == 'reference_data':
return 2
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
@defer_draw
def _on_xatt_change(self, *args):
if self.x_att is not None:
if self._display_world:
self.x_att_world = self.reference_data.world_component_ids[self.x_att.axis]
else:
self.x_att_world = self.x_att
@defer_draw
def _on_yatt_change(self, *args):
if self.y_att is not None:
if self._display_world:
self.y_att_world = self.reference_data.world_component_ids[self.y_att.axis]
else:
self.y_att_world = self.y_att
@defer_draw
def _on_xatt_world_change(self, *args):
if self.x_att_world is not None:
with delay_callback(self, 'y_att_world', 'x_att'):
if self.x_att_world == self.y_att_world:
if self._display_world:
world_ids = self.reference_data.world_component_ids
else:
world_ids = self.reference_data.pixel_component_ids
if self.x_att_world == world_ids[-1]:
self.y_att_world = world_ids[-2]
else:
self.y_att_world = world_ids[-1]
if self._display_world:
index = self.reference_data.world_component_ids.index(self.x_att_world)
self.x_att = self.reference_data.pixel_component_ids[index]
else:
self.x_att = self.x_att_world
@defer_draw
def _on_yatt_world_change(self, *args):
if self.y_att_world is not None:
with delay_callback(self, 'x_att_world', 'y_att'):
if self.y_att_world == self.x_att_world:
if self._display_world:
world_ids = self.reference_data.world_component_ids
else:
world_ids = self.reference_data.pixel_component_ids
if self.y_att_world == world_ids[-1]:
self.x_att_world = world_ids[-2]
else:
self.x_att_world = world_ids[-1]
if self._display_world:
index = self.reference_data.world_component_ids.index(self.y_att_world)
self.y_att = self.reference_data.pixel_component_ids[index]
else:
self.y_att = self.y_att_world
def _set_reference_data(self):
if self.reference_data is None:
for layer in self.layers:
if isinstance(layer.layer, BaseData):
self.reference_data = layer.layer
return
def _set_default_slices(self):
# Need to make sure this gets called immediately when reference_data is changed
if self.reference_data is None:
self.slices = ()
else:
self.slices = (0,) * self.reference_data.ndim
@property
def numpy_slice_aggregation_transpose(self):
"""
Returns slicing information usable by Numpy.
This returns two objects: the first is an object that can be used to
slice Numpy arrays and return a 2D array, and the second object is a
boolean indicating whether to transpose the result.
"""
if self.reference_data is None:
return None
slices = []
agg_func = []
for i in range(self.reference_data.ndim):
if i == self.x_att.axis or i == self.y_att.axis:
slices.append(slice(None))
agg_func.append(None)
else:
if isinstance(self.slices[i], AggregateSlice):
slices.append(self.slices[i].slice)
agg_func.append(self.slices[i].function)
else:
slices.append(self.slices[i])
transpose = self.y_att.axis > self.x_att.axis
return slices, agg_func, transpose
@property
def wcsaxes_slice(self):
"""
Returns slicing information usable by WCSAxes.
This returns an iterable of slices, and including ``'x'`` and ``'y'``
for the dimensions along which we are not slicing.
"""
if self.reference_data is None:
return None
slices = []
for i in range(self.reference_data.ndim):
if i == self.x_att.axis:
slices.append('x')
elif i == self.y_att.axis:
slices.append('y')
else:
if isinstance(self.slices[i], AggregateSlice):
slices.append(self.slices[i].center)
else:
slices.append(self.slices[i])
return slices[::-1]
def flip_x(self):
"""
Flip the x_min/x_max limits.
"""
with delay_callback(self, 'x_min', 'x_max'):
self.x_min, self.x_max = self.x_max, self.x_min
def flip_y(self):
"""
Flip the y_min/y_max limits.
"""
with delay_callback(self, 'y_min', 'y_max'):
self.y_min, self.y_max = self.y_max, self.y_min
class BaseImageLayerState(MatplotlibLayerState):
_viewer_callbacks_set = False
_image_cache = None
_pixel_cache = None
def get_sliced_data_shape(self, view=None):
if (self.viewer_state.reference_data is None or
self.viewer_state.x_att is None or
self.viewer_state.y_att is None):
return None
x_axis = self.viewer_state.x_att.axis
y_axis = self.viewer_state.y_att.axis
shape = self.viewer_state.reference_data.shape
shape_slice = shape[y_axis], shape[x_axis]
if view is None:
return shape_slice
else:
return view_shape(shape_slice, view)
def get_sliced_data(self, view=None, bounds=None):
full_view, agg_func, transpose = self.viewer_state.numpy_slice_aggregation_transpose
x_axis = self.viewer_state.x_att.axis
y_axis = self.viewer_state.y_att.axis
# For this method, we make use of Data.compute_fixed_resolution_buffer,
# which requires us to specify bounds in the form (min, max, nsteps).
# We also allow view to be passed here (which is a normal Numpy view)
# and, if given, translate it to bounds. If neither are specified,
# we behave as if view was [slice(None), slice(None)].
def slice_to_bound(slc, size):
min, max, step = slc.indices(size)
n = (max - min - 1) // step
max = min + step * n
return (min, max, n + 1)
if bounds is None:
# The view should be that which should just be applied to the data
# slice, not to all the dimensions of the data - thus it should have at
# most two dimensions
if view is None:
view = [slice(None), slice(None)]
elif len(view) == 1:
view = view + [slice(None)]
elif len(view) > 2:
raise ValueError('view should have at most two elements')
full_view[x_axis] = view[1]
full_view[y_axis] = view[0]
else:
full_view[x_axis] = bounds[1]
full_view[y_axis] = bounds[0]
for i in range(self.viewer_state.reference_data.ndim):
if isinstance(full_view[i], slice):
full_view[i] = slice_to_bound(full_view[i], self.viewer_state.reference_data.shape[i])
# We now get the fixed resolution buffer
if isinstance(self.layer, BaseData):
image = self.layer.compute_fixed_resolution_buffer(full_view, target_data=self.viewer_state.reference_data,
target_cid=self.attribute, broadcast=False, cache_id=self.uuid)
else:
image = self.layer.data.compute_fixed_resolution_buffer(full_view, target_data=self.viewer_state.reference_data,
subset_state=self.layer.subset_state, broadcast=False, cache_id=self.uuid)
# We apply aggregation functions if needed
if agg_func is None:
if image.ndim != 2:
raise IncompatibleDataException()
else:
if image.ndim != len(agg_func):
raise ValueError("Sliced image dimensions ({0}) does not match "
"aggregation function list ({1})"
.format(image.ndim, len(agg_func)))
for axis in range(image.ndim - 1, -1, -1):
func = agg_func[axis]
if func is not None:
image = func(image, axis=axis)
if image.ndim != 2:
raise ValueError("Image after aggregation should have two dimensions")
# And finally we transpose the data if the order of x/y is different
# from the native order.
if transpose:
image = image.transpose()
return image
class ImageLayerState(BaseImageLayerState):
"""
A state class that includes all the attributes for data layers in an image plot.
"""
attribute = DDSCProperty(docstring='The attribute shown in the layer')
v_min = DDCProperty(docstring='The lower level shown')
v_max = DDCProperty(docstring='The upper level shown')
percentile = DDSCProperty(docstring='The percentile value used to '
'automatically calculate levels')
contrast = DDCProperty(1, docstring='The contrast of the layer')
bias = DDCProperty(0.5, docstring='A constant value that is added to the '
'layer before rendering')
cmap = DDCProperty(docstring='The colormap used to render the layer')
stretch = DDSCProperty(docstring='The stretch used to render the layer, '
'which should be one of ``linear``, '
'``sqrt``, ``log``, or ``arcsinh``')
global_sync = DDCProperty(False, docstring='Whether the color and transparency '
'should be synced with the global '
'color and transparency for the data')
def __init__(self, layer=None, viewer_state=None, **kwargs):
self.uuid = str(uuid.uuid4())
super(ImageLayerState, self).__init__(layer=layer, viewer_state=viewer_state)
self.attribute_lim_helper = StateAttributeLimitsHelper(self, attribute='attribute',
percentile='percentile',
lower='v_min', upper='v_max')
self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute',
numeric=True, categorical=False)
percentile_display = {100: 'Min/Max',
99.5: '99.5%',
99: '99%',
95: '95%',
90: '90%',
'Custom': 'Custom'}
ImageLayerState.percentile.set_choices(self, [100, 99.5, 99, 95, 90, 'Custom'])
ImageLayerState.percentile.set_display_func(self, percentile_display.get)
stretch_display = {'linear': 'Linear',
'sqrt': 'Square Root',
'arcsinh': 'Arcsinh',
'log': 'Logarithmic'}
ImageLayerState.stretch.set_choices(self, ['linear', 'sqrt', 'arcsinh', 'log'])
ImageLayerState.stretch.set_display_func(self, stretch_display.get)
self.add_callback('global_sync', self._update_syncing)
self.add_callback('layer', self._update_attribute)
self._update_syncing()
if layer is not None:
self._update_attribute()
self.update_from_dict(kwargs)
if self.cmap is None:
self.cmap = self.layer.style.preferred_cmap or colormaps.members[0][1]
def _update_attribute(self, *args):
if self.layer is not None:
self.attribute_att_helper.set_multiple_data([self.layer])
self.attribute = self.layer.main_components[0]
def _update_priority(self, name):
if name == 'layer':
return 3
elif name == 'attribute':
return 2
elif name == 'global_sync':
return 1.5
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
def _update_syncing(self, *args):
if self.global_sync:
self._sync_color.enable_syncing()
self._sync_alpha.enable_syncing()
else:
self._sync_color.disable_syncing()
self._sync_alpha.disable_syncing()
def _get_image(self, view=None):
return self.layer[self.attribute, view]
def flip_limits(self):
"""
Flip the image levels.
"""
self.attribute_lim_helper.flip_limits()
def reset_contrast_bias(self):
with delay_callback(self, 'contrast', 'bias'):
self.contrast = 1
self.bias = 0.5
class ImageSubsetLayerState(BaseImageLayerState):
"""
A state class that includes all the attributes for subset layers in an image plot.
"""
# TODO: we can save memory by not showing subset multiple times for
# different image datasets since the footprint should be the same.
def __init__(self, *args, **kwargs):
self.uuid = str(uuid.uuid4())
super(ImageSubsetLayerState, self).__init__(*args, **kwargs)
def _get_image(self, view=None):
return self.layer.to_mask(view=view)
glueviz-1.0.1+dfsg.orig/glue/viewers/image/__init__.py 0000644 0001750 0001750 00000000000 13502206677 022215 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/image/compat.py 0000644 0001750 0001750 00000011403 13605357235 021753 0 ustar noahfx noahfx import uuid
import numpy as np
from glue.viewers.image.state import ImageLayerState, ImageSubsetLayerState
from glue.viewers.scatter.state import ScatterLayerState
STATE_CLASS = {}
STATE_CLASS['ImageLayerArtist'] = ImageLayerState
STATE_CLASS['ScatterLayerArtist'] = ScatterLayerState
STATE_CLASS['SubsetImageLayerArtist'] = ImageSubsetLayerState
class DS9Compat(object):
@classmethod
def __setgluestate__(cls, rec, context):
result = cls()
for k, v in rec.items():
setattr(result, k, v)
return result
def update_image_viewer_state(rec, context):
"""
Given viewer session information, make sure the session information is
compatible with the current version of the viewers, and if not, update
the session information in-place.
"""
if '_protocol' not in rec:
# Note that files saved with protocol < 1 have bin settings saved per
# layer but they were always restricted to be the same, so we can just
# use the settings from the first layer
rec['state'] = {}
rec['state']['values'] = {}
# TODO: could generalize this into a mapping
properties = rec.pop('properties')
viewer_state = rec['state']['values']
viewer_state['color_mode'] = 'st__Colormaps'
viewer_state['reference_data'] = properties['data']
data = context.object(properties['data'])
# TODO: add an id method to unserializer
x_index = properties['slice'].index('x')
y_index = properties['slice'].index('y')
viewer_state['x_att_world'] = str(uuid.uuid4())
context.register_object(viewer_state['x_att_world'], data.world_component_ids[x_index])
viewer_state['y_att_world'] = str(uuid.uuid4())
context.register_object(viewer_state['y_att_world'], data.world_component_ids[y_index])
viewer_state['x_att'] = str(uuid.uuid4())
context.register_object(viewer_state['x_att'], data.pixel_component_ids[x_index])
viewer_state['y_att'] = str(uuid.uuid4())
context.register_object(viewer_state['y_att'], data.pixel_component_ids[y_index])
viewer_state['x_min'] = -0.5
viewer_state['x_max'] = data.shape[1] - 0.5
viewer_state['y_min'] = -0.5
viewer_state['y_max'] = data.shape[0] - 0.5
viewer_state['aspect'] = 'st__equal'
# Slicing with cubes
viewer_state['slices'] = [s if np.isreal(s) else 0 for s in properties['slice']]
# RGB mode
for layer in rec['layers'][:]:
if layer['_type'].split('.')[-1] == 'RGBImageLayerArtist':
for icolor, color in enumerate('rgb'):
new_layer = {}
new_layer['_type'] = 'glue.viewers.image.layer_artist.ImageLayerArtist'
new_layer['layer'] = layer['layer']
new_layer['attribute'] = layer[color]
new_layer['norm'] = layer[color + 'norm']
new_layer['zorder'] = layer['zorder']
new_layer['visible'] = layer['color_visible'][icolor]
new_layer['color'] = color
rec['layers'].append(new_layer)
rec['layers'].remove(layer)
viewer_state['color_mode'] = 'st__One color per layer'
layer_states = []
for layer in rec['layers']:
state_id = str(uuid.uuid4())
state_cls = STATE_CLASS[layer['_type'].split('.')[-1]]
state = state_cls(layer=context.object(layer.pop('layer')))
for prop in ('visible', 'zorder'):
value = layer.pop(prop)
value = context.object(value)
setattr(state, prop, value)
if 'attribute' in layer:
state.attribute = context.object(layer['attribute'])
else:
state.attribute = context.object(properties['attribute'])
if 'norm' in layer:
norm = context.object(layer['norm'])
state.bias = norm.bias
state.contrast = norm.contrast
state.stretch = norm.stretch
if norm.clip_hi is not None:
state.percentile = norm.clip_hi
else:
if norm.vmax is not None:
state.v_min = norm.vmin
state.v_max = norm.vmax
state.percentile = 'Custom'
if 'color' in layer:
state.global_sync = False
state.color = layer['color']
context.register_object(state_id, state)
layer['state'] = state_id
layer_states.append(state)
list_id = str(uuid.uuid4())
context.register_object(list_id, layer_states)
rec['state']['values']['layers'] = list_id
glueviz-1.0.1+dfsg.orig/glue/viewers/image/pixel_selection_subset_state.py 0000644 0001750 0001750 00000004447 13605357235 026455 0 ustar noahfx noahfx import numpy as np
from glue.core.subset import SliceSubsetState
from glue.core.exceptions import IncompatibleAttribute
from glue.core.link_manager import pixel_cid_to_pixel_cid_matrix
__all__ = ['PixelSubsetState']
class PixelSubsetState(SliceSubsetState):
def copy(self):
return PixelSubsetState(self.reference_data, self.slices)
def to_array(self, data, att):
try:
return super(PixelSubsetState, self).to_array(data, att)
except IncompatibleAttribute:
if data is not self.reference_data:
pix_coord_out = self._to_linked_pixel_coords(data)
pix_coord_out = tuple([slice(None) if p is None else slice(p, p + 1) for p in pix_coord_out])
return data[att, pix_coord_out]
raise IncompatibleAttribute()
def _to_linked_pixel_coords(self, data):
# Determine which pixel dimensions are being sliced over
dimensions = [idim for idim, slc in enumerate(self.slices) if slc.start is not None]
# Determine pixel to pixel correlation matrix
matrix = pixel_cid_to_pixel_cid_matrix(self.reference_data, data)
# Find pixel dimensions in 'data' that are correlated
correlated_dims = np.nonzero(np.any(matrix[dimensions], axis=0))[0]
# Check that if we do the operation backwards we just get the
# original dimensions back
check_dimensions = np.nonzero(np.any(matrix[:, correlated_dims], axis=1))[0]
if np.array_equal(dimensions, check_dimensions):
pix_coord_in = tuple([slice(0, 1) if slc.start is None else slc for slc in self.slices])
pix_coord_out = []
for idim, pix_cid in enumerate(data.pixel_component_ids):
if idim in correlated_dims:
coord = int(np.round(self.reference_data[pix_cid, pix_coord_in].ravel()[0]))
else:
coord = None
pix_coord_out.append(coord)
return pix_coord_out
raise IncompatibleAttribute()
def get_xy(self, data, dim1, dim2):
pix_coord_out = self._to_linked_pixel_coords(data)
if pix_coord_out[dim1] is None or pix_coord_out[dim2] is None:
raise IncompatibleAttribute
else:
return pix_coord_out[dim1], pix_coord_out[dim2]
glueviz-1.0.1+dfsg.orig/glue/viewers/image/layer_artist.py 0000644 0001750 0001750 00000032114 13661230662 023170 0 ustar noahfx noahfx import uuid
import weakref
import numpy as np
import matplotlib.patches as mpatches
import matplotlib.colors as mcolors
from glue.utils import defer_draw, broadcast_to
from glue.viewers.image.state import ImageLayerState, ImageSubsetLayerState
from glue.viewers.image.python_export import python_export_image_layer, python_export_image_subset_layer
from glue.viewers.image.pixel_selection_subset_state import PixelSubsetState
from glue.viewers.matplotlib.layer_artist import MatplotlibLayerArtist
from glue.core.exceptions import IncompatibleAttribute
from glue.utils import color2rgb
from glue.utils.matplotlib import ColormapPatchHandler
from glue.core import BaseData, HubListener
from glue.core.message import (ComponentsChangedMessage,
ExternallyDerivableComponentsChangedMessage,
PixelAlignedDataChangedMessage)
from glue.viewers.image.frb_artist import imshow
from glue.core.fixed_resolution_buffer import ARRAY_CACHE, PIXEL_CACHE
class BaseImageLayerArtist(MatplotlibLayerArtist, HubListener):
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(BaseImageLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# Watch for changes in the viewer state which would require the
# layers to be redrawn
self._viewer_state.add_global_callback(self._update_image)
self.state.add_global_callback(self._update_image)
self.layer.hub.subscribe(self, ComponentsChangedMessage,
handler=self.update,
filter=self._is_data_object)
self.layer.hub.subscribe(self, ExternallyDerivableComponentsChangedMessage,
handler=self.update,
filter=self._is_data_object)
self.layer.hub.subscribe(self, PixelAlignedDataChangedMessage,
handler=self.update,
filter=self._is_data_object)
def _is_data_object(self, message):
if isinstance(self.layer, BaseData):
return message.sender is self.layer
else:
return message.sender is self.layer.data
def _update_image(self, force=False, **kwargs):
raise NotImplementedError()
class ImageLayerArtist(BaseImageLayerArtist):
_layer_state_cls = ImageLayerState
_python_exporter = python_export_image_layer
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(ImageLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# We use a custom object to deal with the compositing of images, and we
# store it as a private attribute of the axes to make sure it is
# accessible for all layer artists.
self.uuid = str(uuid.uuid4())
self.composite = self.axes._composite
self.composite.allocate(self.uuid)
self.composite.set(self.uuid, array=self.get_image_data,
shape=self.get_image_shape)
self.composite_image = self.axes._composite_image
@property
def label(self):
return "%s (%s)" % (self.layer.label, self.state.attribute.label)
def get_layer_color(self):
if self._viewer_state.color_mode == 'One color per layer':
return self.state.color
else:
return self.state.cmap
def get_handle_legend(self):
if self.enabled and self.state.visible:
# a fancier patch drawing the colormap
color = self.get_layer_color()
label = self.layer.label
if isinstance(color, mcolors.Colormap):
handle = mpatches.Patch(color=color(0.5))
# actual color of the handle is not important
handler = ColormapPatchHandler(color)
else:
handle = mpatches.Patch(color=color, alpha=self.layer.style.alpha)
handler = None # default handler is good enough
return handle, label, handler
else:
return None, None, None
def enable(self):
if hasattr(self, 'composite_image'):
self.composite_image.invalidate_cache()
super(ImageLayerArtist, self).enable()
def remove(self):
super(ImageLayerArtist, self).remove()
if self.uuid in self.composite:
self.composite.deallocate(self.uuid)
self.composite_image.invalidate_cache()
ARRAY_CACHE.pop(self.state.uuid, None)
PIXEL_CACHE.pop(self.state.uuid, None)
self.uuid = None
def get_image_shape(self):
if self.uuid is None or self._viewer_state.reference_data is None or self._viewer_state.x_att is None or self._viewer_state.y_att is None:
return None
x_axis = self._viewer_state.x_att.axis
y_axis = self._viewer_state.y_att.axis
full_shape = self._viewer_state.reference_data.shape
return full_shape[y_axis], full_shape[x_axis]
def get_image_data(self, bounds=None):
if self.uuid is None:
return None
try:
image = self.state.get_sliced_data(bounds=bounds)
except (IncompatibleAttribute, IndexError):
# The following includes a call to self.clear()
self.disable_invalid_attributes(self.state.attribute)
return None
else:
self.enable()
return image
def _update_image_data(self):
self.composite_image.invalidate_cache()
self.redraw()
@defer_draw
def _update_visual_attributes(self):
if not self.enabled:
return
if self._viewer_state.color_mode == 'Colormaps':
color = self.state.cmap
else:
color = self.state.color
self.composite.set(self.uuid,
clim=(self.state.v_min, self.state.v_max),
visible=self.state.visible,
zorder=self.state.zorder,
color=color,
contrast=self.state.contrast,
bias=self.state.bias,
alpha=self.state.alpha,
stretch=self.state.stretch)
self.composite_image.invalidate_cache()
self.redraw()
@defer_draw
def _update_image(self, force=False, **kwargs):
if self.uuid is None or self.state.attribute is None or self.state.layer is None:
return
changed = set() if force else self.pop_changed_properties()
if force or any(prop in changed for prop in ('layer', 'attribute',
'slices', 'x_att', 'y_att')):
self._update_image_data()
force = True # make sure scaling and visual attributes are updated
if force or any(prop in changed for prop in ('v_min', 'v_max', 'contrast',
'bias', 'alpha', 'color_mode',
'cmap', 'color', 'zorder',
'visible', 'stretch')):
self._update_visual_attributes()
@defer_draw
def update(self, *event):
ARRAY_CACHE.pop(self.state.uuid, None)
PIXEL_CACHE.pop(self.state.uuid, None)
self._update_image(force=True)
self.redraw()
class ImageSubsetArray(object):
def __init__(self, viewer_state, layer_artist):
self._viewer_state = weakref.ref(viewer_state)
self._layer_artist = weakref.ref(layer_artist)
self._layer_state = weakref.ref(layer_artist.state)
@property
def layer_artist(self):
return self._layer_artist()
@property
def layer_state(self):
return self._layer_state()
@property
def viewer_state(self):
return self._viewer_state()
@property
def shape(self):
x_axis = self.viewer_state.x_att.axis
y_axis = self.viewer_state.y_att.axis
full_shape = self.viewer_state.reference_data.shape
return full_shape[y_axis], full_shape[x_axis]
def __call__(self, bounds):
if (self.layer_artist is None or
self.layer_state is None or
self.viewer_state is None):
return broadcast_to(np.nan, self.shape)
# We should compute the mask even if the layer is not visible as we need
# the layer to show up properly when it is made visible (which doesn't
# trigger __getitem__)
try:
mask = self.layer_state.get_sliced_data(bounds=bounds)
except IncompatibleAttribute:
self.layer_artist.disable_incompatible_subset()
return broadcast_to(np.nan, self.shape)
else:
self.layer_artist.enable(redraw=False)
r, g, b = color2rgb(self.layer_state.color)
mask = np.dstack((r * mask, g * mask, b * mask, mask * .5))
mask = (255 * mask).astype(np.uint8)
return mask
@property
def dtype(self):
return np.uint8
@property
def ndim(self):
return 2
@property
def size(self):
return np.product(self.shape)
class ImageSubsetLayerArtist(BaseImageLayerArtist):
_layer_state_cls = ImageSubsetLayerState
_python_exporter = python_export_image_subset_layer
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(ImageSubsetLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
self.subset_array = ImageSubsetArray(self._viewer_state, self)
self.image_artist = imshow(self.axes, self.subset_array,
origin='lower', interpolation='nearest',
vmin=0, vmax=1, aspect='auto')
self._line_x = self.axes.axvline(0)
self._line_x.set_visible(False)
self._line_y = self.axes.axhline(0)
self._line_y.set_visible(False)
self.mpl_artists = [self.image_artist, self._line_x, self._line_y]
@defer_draw
def _update_data(self):
if isinstance(self.state.layer.subset_state, PixelSubsetState):
try:
x, y = self.state.layer.subset_state.get_xy(self.layer.data,
self._viewer_state.x_att.axis,
self._viewer_state.y_att.axis)
except IncompatibleAttribute:
self._line_x.set_visible(False)
self._line_y.set_visible(False)
else:
self._line_x.set_data([x, x], [0, 1])
self._line_x.set_visible(True)
self._line_y.set_data([0, 1], [y, y])
self._line_y.set_visible(True)
else:
self._line_x.set_visible(False)
self._line_y.set_visible(False)
self.image_artist.invalidate_cache()
@defer_draw
def _update_visual_attributes(self, redraw=True):
if not self.enabled:
return
for artist in self.mpl_artists:
if artist is self.image_artist:
artist.set_visible(self.state.visible)
artist.set_alpha(self.state.alpha)
else:
if self.state.visible:
artist.set_visible(isinstance(self.state.layer.subset_state, PixelSubsetState))
else:
artist.set_visible(False)
artist.set_color(self.state.color)
artist.set_alpha(self.state.alpha * 0.5)
artist.set_zorder(self.state.zorder)
if redraw:
self.redraw()
def _update_image(self, force=False, **kwargs):
if self.state.layer is None:
return
changed = set() if force else self.pop_changed_properties()
if force or any(prop in changed for prop in ('layer', 'attribute', 'color',
'x_att', 'y_att', 'slices')):
self._update_data()
force = True # make sure scaling and visual attributes are updated
if force or any(prop in changed for prop in ('zorder', 'visible', 'alpha')):
self._update_visual_attributes()
def remove(self):
super(ImageSubsetLayerArtist, self).remove()
self.image_artist.invalidate_cache()
ARRAY_CACHE.pop(self.state.uuid, None)
PIXEL_CACHE.pop(self.state.uuid, None)
def enable(self, redraw=True):
super(ImageSubsetLayerArtist, self).enable()
# We need to now ensure that image_artist, which may have been marked
# as not being visible when the layer was cleared is made visible
# again.
if hasattr(self, 'image_artist'):
self.image_artist.invalidate_cache()
self._update_visual_attributes(redraw=redraw)
@defer_draw
def update(self, *event):
ARRAY_CACHE.pop(self.state.uuid, None)
PIXEL_CACHE.pop(self.state.uuid, None)
self._update_image(force=True)
self.redraw()
glueviz-1.0.1+dfsg.orig/glue/viewers/image/composite_array.py 0000644 0001750 0001750 00000011702 13605357235 023672 0 ustar noahfx noahfx # This artist can be used to deal with the sampling of the data as well as any
# RGB blending.
import numpy as np
from matplotlib.colors import ColorConverter, Colormap
from astropy.visualization import (LinearStretch, SqrtStretch, AsinhStretch,
LogStretch, ManualInterval, ContrastBiasStretch)
__all__ = ['CompositeArray']
COLOR_CONVERTER = ColorConverter()
STRETCHES = {
'linear': LinearStretch,
'sqrt': SqrtStretch,
'arcsinh': AsinhStretch,
'log': LogStretch
}
class CompositeArray(object):
def __init__(self, **kwargs):
# We keep a dictionary of layers. The key should be the UUID of the
# layer artist, and the values should be dictionaries that contain
# 'zorder', 'visible', 'array', 'color', and 'alpha'.
self.layers = {}
self._first = True
def allocate(self, uuid):
self.layers[uuid] = {'zorder': 0,
'visible': True,
'array': None,
'shape': None,
'color': '0.5',
'alpha': 1,
'clim': (0, 1),
'contrast': 1,
'bias': 0.5,
'stretch': 'linear'}
def deallocate(self, uuid):
self.layers.pop(uuid)
def set(self, uuid, **kwargs):
for key, value in kwargs.items():
if key not in self.layers[uuid]:
raise KeyError("Unknown key: {0}".format(key))
else:
self.layers[uuid][key] = value
@property
def shape(self):
for layer in self.layers.values():
if callable(layer['shape']):
shape = layer['shape']()
elif layer['shape'] is not None:
shape = layer['shape']
elif callable(layer['array']):
array = layer['array']()
if array is None:
return None
else:
shape = array.shape
else:
shape = layer['array'].shape
if shape is not None:
return shape
return None
def __getitem__(self, item):
return self()[item]
def __call__(self, bounds=None):
img = None
visible_layers = 0
for uuid in sorted(self.layers, key=lambda x: self.layers[x]['zorder']):
layer = self.layers[uuid]
if not layer['visible']:
continue
interval = ManualInterval(*layer['clim'])
contrast_bias = ContrastBiasStretch(layer['contrast'], layer['bias'])
if callable(layer['array']):
array = layer['array'](bounds=bounds)
else:
array = layer['array']
if array is None:
continue
if np.isscalar(array):
scalar = True
array = np.atleast_2d(array)
else:
scalar = False
data = STRETCHES[layer['stretch']]()(contrast_bias(interval(array)))
data[np.isnan(data)] = 0
if isinstance(layer['color'], Colormap):
if img is None:
img = np.ones(data.shape + (4,))
# Compute colormapped image
plane = layer['color'](data)
alpha_plane = layer['alpha'] * plane[:, :, 3]
# Use traditional alpha compositing
plane[:, :, 0] = plane[:, :, 0] * alpha_plane
plane[:, :, 1] = plane[:, :, 1] * alpha_plane
plane[:, :, 2] = plane[:, :, 2] * alpha_plane
img[:, :, 0] *= (1 - alpha_plane)
img[:, :, 1] *= (1 - alpha_plane)
img[:, :, 2] *= (1 - alpha_plane)
img[:, :, 3] = 1
else:
if img is None:
img = np.zeros(data.shape + (4,))
# Get color and pre-multiply by alpha values
color = COLOR_CONVERTER.to_rgba_array(layer['color'])[0]
color *= layer['alpha']
# We should treat NaN values as zero (post-stretch), which means
# that those pixels don't contribute towards the final image.
reset = np.isnan(data)
if np.any(reset):
data[reset] = 0.
plane = data[:, :, np.newaxis] * color
plane[:, :, 3] = 1
visible_layers += 1
if scalar:
plane = plane[0, 0]
img += plane
if img is None:
return None
else:
img = np.clip(img, 0, 1)
return img
@property
def dtype(self):
return np.float
@property
def ndim(self):
return 2
@property
def size(self):
return np.product(self.shape)
def __contains__(self, item):
return item in self.layers
glueviz-1.0.1+dfsg.orig/glue/viewers/image/viewer.py 0000644 0001750 0001750 00000022523 13661230662 021772 0 ustar noahfx noahfx import os
from astropy.wcs import WCS
from glue.core.subset import roi_to_subset_state
from glue.core.coordinates import Coordinates, LegacyCoordinates
from glue.core.coordinate_helpers import dependent_axes
from glue.viewers.scatter.layer_artist import ScatterLayerArtist
from glue.viewers.image.layer_artist import ImageLayerArtist, ImageSubsetLayerArtist
from glue.viewers.image.compat import update_image_viewer_state
from glue.viewers.image.frb_artist import imshow
from glue.viewers.image.composite_array import CompositeArray
__all__ = ['MatplotlibImageMixin']
def get_identity_wcs(naxis):
wcs = WCS(naxis=naxis)
wcs.wcs.ctype = ['X'] * naxis
wcs.wcs.crval = [0.] * naxis
wcs.wcs.crpix = [1.] * naxis
wcs.wcs.cdelt = [1.] * naxis
return wcs
EXTRA_FOOTER = """
# Set tick label size - for now tick_params (called lower down) doesn't work
# properly, but these lines won't be needed in future.
ax.coords[{x_att_axis}].set_ticklabel(size={x_ticklabel_size})
ax.coords[{y_att_axis}].set_ticklabel(size={y_ticklabel_size})
""".strip()
class MatplotlibImageMixin(object):
def setup_callbacks(self):
self._wcs_set = False
self._changing_slice_requires_wcs_update = None
self.axes.set_adjustable('datalim')
self.state.add_callback('x_att', self._set_wcs)
self.state.add_callback('y_att', self._set_wcs)
self.state.add_callback('slices', self._on_slice_change)
self.state.add_callback('reference_data', self._set_wcs)
self.axes._composite = CompositeArray()
self.axes._composite_image = imshow(self.axes, self.axes._composite, aspect='auto',
origin='lower', interpolation='nearest')
self._set_wcs()
def update_x_ticklabel(self, *event):
# We need to overload this here for WCSAxes
if hasattr(self, '_wcs_set') and self._wcs_set and self.state.x_att is not None:
axis = self.state.reference_data.ndim - self.state.x_att.axis - 1
else:
axis = 0
self.axes.coords[axis].set_ticklabel(size=self.state.x_ticklabel_size)
self.redraw()
def update_y_ticklabel(self, *event):
# We need to overload this here for WCSAxes
if hasattr(self, '_wcs_set') and self._wcs_set and self.state.y_att is not None:
axis = self.state.reference_data.ndim - self.state.y_att.axis - 1
else:
axis = 1
self.axes.coords[axis].set_ticklabel(size=self.state.y_ticklabel_size)
self.redraw()
def _update_axes(self, *args):
if self.state.x_att_world is not None:
self.state.x_axislabel = self.state.x_att_world.label
if self.state.y_att_world is not None:
self.state.y_axislabel = self.state.y_att_world.label
self.axes.figure.canvas.draw_idle()
def add_data(self, data):
result = super(MatplotlibImageMixin, self).add_data(data)
# If this is the first layer (or the first after all layers were)
# removed, set the WCS for the axes.
if len(self.layers) == 1:
self._set_wcs()
return result
def _on_slice_change(self, event=None):
if self._changing_slice_requires_wcs_update:
self._set_wcs(event=event, relim=False)
def _set_wcs(self, event=None, relim=True):
if self.state.x_att is None or self.state.y_att is None or self.state.reference_data is None:
return
ref_coords = getattr(self.state.reference_data, 'coords', None)
if ref_coords is None or isinstance(ref_coords, LegacyCoordinates):
self.axes.reset_wcs(slices=self.state.wcsaxes_slice,
wcs=get_identity_wcs(self.state.reference_data.ndim))
else:
self.axes.reset_wcs(slices=self.state.wcsaxes_slice, wcs=ref_coords)
# Reset the axis labels to match the fact that the new axes have no labels
self.state.x_axislabel = ''
self.state.y_axislabel = ''
self._update_appearance_from_settings()
self._update_axes()
self.update_x_ticklabel()
self.update_y_ticklabel()
if relim:
self.state.reset_limits()
# Determine whether changing slices requires changing the WCS
if ref_coords is None or type(ref_coords) == Coordinates:
self._changing_slice_requires_wcs_update = False
else:
ix = self.state.x_att.axis
iy = self.state.y_att.axis
x_dep = list(dependent_axes(ref_coords, ix))
y_dep = list(dependent_axes(ref_coords, iy))
if ix in x_dep:
x_dep.remove(ix)
if iy in x_dep:
x_dep.remove(iy)
if ix in y_dep:
y_dep.remove(ix)
if iy in y_dep:
y_dep.remove(iy)
self._changing_slice_requires_wcs_update = bool(x_dep or y_dep)
self._wcs_set = True
def apply_roi(self, roi, override_mode=None):
# Force redraw to get rid of ROI. We do this because applying the
# subset state below might end up not having an effect on the viewer,
# for example there may not be any layers, or the active subset may not
# be one of the layers. So we just explicitly redraw here to make sure
# a redraw will happen after this method is called.
self.redraw()
if len(self.layers) == 0:
return
if self.state.x_att is None or self.state.y_att is None or self.state.reference_data is None:
return
subset_state = roi_to_subset_state(roi,
x_att=self.state.x_att,
y_att=self.state.y_att)
self.apply_subset_state(subset_state, override_mode=override_mode)
def _scatter_artist(self, axes, state, layer=None, layer_state=None):
if len(self._layer_artist_container) == 0:
raise Exception("Can only add a scatter plot overlay once an image is present")
return ScatterLayerArtist(axes, state, layer=layer, layer_state=None)
def get_data_layer_artist(self, layer=None, layer_state=None):
if layer.ndim == 1:
cls = self._scatter_artist
else:
cls = ImageLayerArtist
return self.get_layer_artist(cls, layer=layer, layer_state=layer_state)
def get_subset_layer_artist(self, layer=None, layer_state=None):
if layer.ndim == 1:
cls = self._scatter_artist
else:
cls = ImageSubsetLayerArtist
return self.get_layer_artist(cls, layer=layer, layer_state=layer_state)
@staticmethod
def update_viewer_state(rec, context):
return update_image_viewer_state(rec, context)
def show_crosshairs(self, x, y):
if getattr(self, '_crosshairs', None) is not None:
self._crosshairs.remove()
self._crosshairs, = self.axes.plot([x], [y], '+', ms=12,
mfc='none', mec='#d32d26',
mew=1, zorder=100)
self.axes.figure.canvas.draw_idle()
def hide_crosshairs(self):
if getattr(self, '_crosshairs', None) is not None:
self._crosshairs.remove()
self._crosshairs = None
self.axes.figure.canvas.draw_idle()
def _script_header(self):
imports = []
imports.append('import matplotlib.pyplot as plt')
imports.append('from glue.viewers.matplotlib.mpl_axes import init_mpl')
imports.append('from glue.viewers.image.composite_array import CompositeArray')
imports.append('from glue.viewers.image.frb_artist import imshow')
script = ""
script += "fig, ax = init_mpl(wcs=True)\n"
script += "ax.set_aspect('{0}')\n".format(self.state.aspect)
script += '\ncomposite = CompositeArray()\n'
script += "image = imshow(ax, composite, origin='lower', interpolation='nearest', aspect='{0}')\n\n".format(self.state.aspect)
dindex = self.session.data_collection.index(self.state.reference_data)
script += "ref_data = data_collection[{0}]\n".format(dindex)
ref_coords = self.state.reference_data.coords
if hasattr(ref_coords, 'wcs'):
script += "ax.reset_wcs(slices={0}, wcs=ref_data.coords.wcs)\n".format(self.state.wcsaxes_slice)
elif hasattr(ref_coords, 'wcsaxes_dict'):
raise NotImplementedError()
else:
imports.append('from glue.viewers.image.viewer import get_identity_wcs')
script += "ax.reset_wcs(slices={0}, wcs=get_identity_wcs(ref_data.ndim))\n".format(self.state.wcsaxes_slice)
script += "# for the legend\n"
script += "legend_handles = []\n"
script += "legend_labels = []\n"
script += "legend_handler_dict = dict()\n\n"
return imports, script
def _script_footer(self):
imports, script = super(MatplotlibImageMixin, self)._script_footer()
options = dict(x_att_axis=0 if self.state.x_att is None else self.state.reference_data.ndim - self.state.x_att.axis - 1,
y_att_axis=1 if self.state.y_att is None else self.state.reference_data.ndim - self.state.y_att.axis - 1,
x_ticklabel_size=self.state.x_ticklabel_size,
y_ticklabel_size=self.state.y_ticklabel_size)
return [], EXTRA_FOOTER.format(**options) + os.linesep * 2 + script
glueviz-1.0.1+dfsg.orig/glue/viewers/__init__.py 0000644 0001750 0001750 00000000000 13455362716 021137 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/ 0000755 0001750 0001750 00000000000 13752535025 020323 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/tests/ 0000755 0001750 0001750 00000000000 13752535025 021465 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/tests/test_viewer.py 0000644 0001750 0001750 00000002703 13502206677 024402 0 ustar noahfx noahfx from glue.config import layer_artist_maker
from glue.core.application_base import Application
from glue.core import Data
from glue.viewers.common.viewer import Viewer
from glue.viewers.common.layer_artist import LayerArtist
def test_custom_layer_artist_maker():
# This is a test of the infrastructure that allows users/developers to
# define custom layer artist makers - i.e. functions that given a dataset
# and a viewer can decide whether to create a custom layer artist rather
# than the default types available for a given viewer.
class CustomLayerArtist(LayerArtist):
pass
class CustomApplication(Application):
def add_widget(self, *args, **kwargs):
pass
@layer_artist_maker('custom_maker')
def custom_maker(viewer, data):
if hasattr(data, 'custom'):
return CustomLayerArtist(viewer.state, layer=data)
app = CustomApplication()
data1 = Data(x=[1, 2, 3], label='test1')
data2 = Data(x=[1, 2, 3], label='test2')
data2.custom = True
app.data_collection.append(data1)
app.data_collection.append(data2)
viewer = app.new_data_viewer(Viewer)
assert len(viewer.layers) == 0
# NOTE: Check exact type, not using isinstance
viewer.add_data(data1)
assert len(viewer.layers) == 1
assert type(viewer.layers[0]) is LayerArtist
viewer.add_data(data2)
assert len(viewer.layers) == 2
assert type(viewer.layers[1]) is CustomLayerArtist
glueviz-1.0.1+dfsg.orig/glue/viewers/common/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 023571 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/tests/test_utils.py 0000644 0001750 0001750 00000002305 13507416115 024232 0 ustar noahfx noahfx from glue.viewers.common.viewer import Viewer
from glue.viewers.common.utils import get_viewer_tools
class ViewerWithTools(Viewer):
inherit_tools = True
tools = ['save']
subtools = {'save': []}
def test_get_viewer_tools():
class CustomViewer1(ViewerWithTools):
pass
tools, subtools = get_viewer_tools(CustomViewer1)
assert tools == ['save']
assert subtools == {'save': []}
class CustomViewer2(ViewerWithTools):
tools = ['banana']
subtools = {'save': ['apple', 'pear']}
tools, subtools = get_viewer_tools(CustomViewer2)
assert tools == ['save', 'banana']
assert subtools == {'save': ['apple', 'pear']}
CustomViewer2.inherit_tools = False
tools, subtools = get_viewer_tools(CustomViewer2)
assert tools == ['banana']
assert subtools == {'save': ['apple', 'pear']}
class Mixin(object):
pass
class CustomViewer3(CustomViewer2, Mixin):
tools = ['orange']
subtools = {'banana': ['one', 'two']}
inherit_tools = True
tools, subtools = get_viewer_tools(CustomViewer3)
assert tools == ['banana', 'orange']
assert subtools == {'save': ['apple', 'pear'], 'banana': ['one', 'two']}
glueviz-1.0.1+dfsg.orig/glue/viewers/common/utils.py 0000644 0001750 0001750 00000002141 13605357235 022035 0 ustar noahfx noahfx __all__ = ['get_viewer_tools']
def get_viewer_tools(cls, tools=None, subtools=None):
"""
Given a viewer class, find all the tools and subtools to include in the
viewer.
Parameters
----------
cls : type
The viewer class for which to look for tools.
tools : list
The list to add the tools to - this is modified in-place.
subtools : dict
The dictionary to add the subtools to - this is modified in-place.
"""
if not hasattr(cls, 'inherit_tools'):
return
if tools is None:
tools = []
if subtools is None:
subtools = {}
if cls.inherit_tools:
for parent_cls in cls.__bases__:
get_viewer_tools(parent_cls, tools, subtools)
for tool_id in cls.tools:
if tool_id not in tools:
tools.append(tool_id)
for tool_id in cls.subtools:
if tool_id not in subtools:
subtools[tool_id] = []
for subtool_id in cls.subtools[tool_id]:
if subtool_id not in subtools[tool_id]:
subtools[tool_id].append(subtool_id)
return tools, subtools
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/ 0000755 0001750 0001750 00000000000 13752535025 020747 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022111 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tests/test_toolbar.py 0000644 0001750 0001750 00000002074 13605357235 025171 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import pytest
from glue.config import viewer_tool
from glue.viewers.common.qt.data_viewer import DataViewer
from glue.viewers.common.tool import Tool
from glue.viewers.common.qt.toolbar import BasicToolbar
from glue.core.tests.util import simple_session
@viewer_tool
class ExampleTool1(Tool):
tool_id = 'TEST1'
tool_tip = 'tes1'
icon = 'glue_square'
shortcut = 'A'
@viewer_tool
class ExampleTool2(Tool):
tool_id = 'TEST2'
tool_tip = 'tes2'
icon = 'glue_square'
shortcut = 'A'
class ExampleViewer2(DataViewer):
_toolbar_cls = BasicToolbar
tools = ['TEST1', 'TEST2']
def __init__(self, session, parent=None):
super(ExampleViewer2, self).__init__(session, parent=parent)
def test_duplicate_shortcut():
session = simple_session()
expected_warning = ("Tools 'TEST1' and 'TEST2' have the same "
r"shortcut \('A'\). Ignoring shortcut for 'TEST2'")
with pytest.warns(UserWarning, match=expected_warning):
ExampleViewer2(session)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024215 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000006024 13605357235 026020 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import numpy as np
from unittest.mock import MagicMock, patch
from glue.core import Data, DataCollection
from glue.app.qt import GlueApplication
from glue.core.tests.util import simple_session
from glue.viewers.histogram.qt import HistogramViewer
from glue.viewers.image.qt import ImageViewer
from glue.viewers.scatter.qt import ScatterViewer
from glue.utils.qt import process_events
# TODO: We should maybe consider running these tests for all
# registered Qt viewers.
class BaseTestDataViewer(object):
ndim = 1
def test_unregister_on_close(self):
session = simple_session()
hub = session.hub
w = self.widget_cls(session)
w.register_to_hub(hub)
with patch.object(w, 'unregister') as unregister:
w.close()
unregister.assert_called_once_with(hub)
def test_single_draw_call_on_create(self):
d = Data(x=np.random.random((2,) * self.ndim))
dc = DataCollection([d])
app = GlueApplication(dc)
try:
from glue.viewers.matplotlib.qt.widget import MplCanvas
draw = MplCanvas.draw
MplCanvas.draw = MagicMock()
app.new_data_viewer(self.widget_cls, data=d)
# each Canvas instance gives at most 1 draw call
selfs = [c[0][0] for c in MplCanvas.draw.call_arg_list]
assert len(set(selfs)) == len(selfs)
finally:
MplCanvas.draw = draw
app.close()
def test_close_on_last_layer_remove(self):
# regression test for 391
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)
process_events()
assert len(app.viewers[0]) == 1
dc.remove(d1)
process_events()
assert len(app.viewers[0]) == 1
dc.remove(d2)
process_events()
assert len(app.viewers[0]) == 0
app.close()
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()
class TestDataViewerScatter(BaseTestDataViewer):
widget_cls = ScatterViewer
class TestDataViewerImage(BaseTestDataViewer):
ndim = 2
widget_cls = ImageViewer
class TestDataViewerHistogram(BaseTestDataViewer):
widget_cls = HistogramViewer
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tests/test_data_slice_widget.py 0000644 0001750 0001750 00000004057 13605357235 027165 0 ustar noahfx noahfx from ..data_slice_widget import SliceWidget
class TestSliceWidget(object):
def test_slice_center(self):
s = SliceWidget(lo=0, hi=10)
assert s.state.slice_center == 5
def test_browse_slice(self):
s = SliceWidget(lo=0, hi=10)
assert s.state.slice_center == 5
s.button_prev.click()
assert s.state.slice_center == 4
s.button_next.click()
s.button_next.click()
assert s.state.slice_center == 6
s.button_first.click()
assert s.state.slice_center == 0
s.button_prev.click()
assert s.state.slice_center == 10
s.button_next.click()
assert s.state.slice_center == 0
s.button_last.click()
assert s.state.slice_center == 10
s.button_next.click()
assert s.state.slice_center == 0
s.button_prev.click()
assert s.state.slice_center == 10
s.button_prev.click()
assert s.state.slice_center == 9
def test_slice_world(self):
s = SliceWidget(lo=0, hi=5, world=[1, 3, 5, 5.5, 8, 12])
# Check switching between world and pixel coordinates
s.state.slice_center = 0
assert s.state.slider_label == '1.0'
s.state.use_world = False
assert s.state.slider_label == '0'
s.state.slice_center = 3
assert s.state.slider_label == '3'
s.state.use_world = True
assert s.state.slider_label == '5.5'
# Round to nearest
s.state.slider_label = '11'
assert s.state.slice_center == 5
assert s.state.slider_label == '12.0'
# Make sure out of bound values work
s.state.slider_label = '20'
assert s.state.slice_center == 5
assert s.state.slider_label == '12.0'
s.state.slider_label = '-10'
assert s.state.slice_center == 0
assert s.state.slider_label == '1.0'
# And disable world and try and set by pixel
s.state.use_world = False
s.state.slider_label = '4'
assert s.state.slice_center == 4
assert s.state.slider_label == '4'
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/toolbar.py 0000644 0001750 0001750 00000016056 13637163236 022776 0 ustar noahfx noahfx import os
import warnings
from qtpy import QtCore, QtGui, QtWidgets
from qtpy.QtCore import Qt
from glue.core.callback_property import add_callback
from glue.viewers.common.tool import CheckableTool, DropdownTool
from glue.icons.qt import get_icon
__all__ = ['BasicToolbar']
class BasicToolbar(QtWidgets.QToolBar):
tool_activated = QtCore.Signal()
tool_deactivated = QtCore.Signal()
def __init__(self, parent, default_mouse_mode_cls=None):
"""
Create a new toolbar object
"""
super(BasicToolbar, self).__init__(parent=parent)
self.actions = {}
self.tools = {}
self.setIconSize(QtCore.QSize(25, 25))
self.layout().setSpacing(1)
self.setFocusPolicy(Qt.StrongFocus)
self._active_tool = None
self._default_mouse_mode_cls = default_mouse_mode_cls
self._default_mouse_mode = None
self.setup_default_modes()
def setup_default_modes(self):
if self._default_mouse_mode_cls is not None:
self._default_mouse_mode = self._default_mouse_mode_cls(self.parent())
self._default_mouse_mode.activate()
@property
def active_tool(self):
return self._active_tool
@active_tool.setter
def active_tool(self, new_tool):
if isinstance(new_tool, str):
if new_tool in self.tools:
new_tool = self.tools[new_tool]
else:
raise ValueError("Unrecognized tool '{0}', should be one of {1}"
.format(new_tool, ", ".join(sorted(self.tools))))
old_tool = self._active_tool
# If the tool is as before, we don't need to do anything
if old_tool is new_tool:
return
# Otheriwse, if the tool changes, then we need to disable the previous
# tool...
if old_tool is not None:
self.deactivate_tool(old_tool)
if isinstance(old_tool, CheckableTool):
button = self.actions[old_tool.tool_id]
if button.isChecked():
button.blockSignals(True)
button.setChecked(False)
button.blockSignals(False)
# We need to then set that no tool is set so that if the next tool
# opens a viewer that needs to check whether a tool is active, we
# know that it isn't.
self._active_tool = None
# ... and enable the new one
if new_tool is not None:
self.activate_tool(new_tool)
if isinstance(new_tool, CheckableTool):
button = self.actions[new_tool.tool_id]
if not button.isChecked():
button.blockSignals(True)
button.setChecked(True)
button.blockSignals(False)
if isinstance(new_tool, CheckableTool):
self._active_tool = new_tool
self.parent().set_status(new_tool.status_tip)
self.tool_activated.emit()
else:
self.parent().set_status('')
self.tool_deactivated.emit()
def activate_tool(self, tool):
if isinstance(tool, CheckableTool) and self._default_mouse_mode is not None:
self._default_mouse_mode.deactivate()
tool.activate()
def deactivate_tool(self, tool):
if isinstance(tool, CheckableTool):
tool.deactivate()
if self._default_mouse_mode is not None:
self._default_mouse_mode.activate()
def _make_action(self, tool, menu=None):
parent = QtWidgets.QToolBar.parent(self)
if isinstance(tool.icon, str):
if os.path.exists(tool.icon):
icon = QtGui.QIcon(tool.icon)
else:
icon = get_icon(tool.icon)
else:
icon = tool.icon
if isinstance(tool, DropdownTool):
# We use a QToolButton here explicitly so that we can make sure
# that the whole button opens the pop-up.
button = QtWidgets.QToolButton()
if tool.action_text:
button.setText(tool.action_text)
if icon:
button.setIcon(icon)
button.setPopupMode(button.InstantPopup)
button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
action = self.addWidget(button)
if menu:
button.setMenu(menu)
button.clicked.connect(button.showMenu)
else:
if icon:
action = QtWidgets.QAction(icon, tool.action_text, parent)
else:
action = QtWidgets.QAction(tool.action_text, parent)
def toggle(checked):
if checked:
self.active_tool = tool
else:
self.active_tool = None
def trigger():
self.active_tool = tool
if isinstance(tool, CheckableTool):
action.toggled.connect(toggle)
else:
action.triggered.connect(trigger)
shortcut = None
if tool.shortcut is not None:
# Make sure that the keyboard shortcut is unique
for m in self.tools.values():
if tool.shortcut == m.shortcut:
warnings.warn("Tools '{0}' and '{1}' have the same shortcut "
"('{2}'). Ignoring shortcut for "
"'{1}'".format(m.tool_id, tool.tool_id, tool.shortcut))
break
else:
shortcut = tool.shortcut
action.setShortcut(tool.shortcut)
action.setShortcutContext(Qt.WidgetShortcut)
if shortcut is None:
action.setToolTip(tool.tool_tip)
else:
action.setToolTip(tool.tool_tip + " [shortcut: {0}]".format(shortcut))
action.setCheckable(isinstance(tool, CheckableTool))
return action
def add_tool(self, tool):
if isinstance(tool, DropdownTool) and len(tool.subtools) > 0:
menu = QtWidgets.QMenu(self)
for t in tool.subtools:
action = self._make_action(t)
menu.addAction(action)
elif len(tool.menu_actions()) > 0:
menu = QtWidgets.QMenu(self)
for ma in tool.menu_actions():
ma.setParent(self)
menu.addAction(ma)
else:
menu = None
action = self._make_action(tool, menu=menu)
self.addAction(action)
self.actions[tool.tool_id] = action
# Bind tool visibility to tool.enabled
def toggle(state):
action.setVisible(state)
action.setEnabled(state)
add_callback(tool, 'enabled', toggle)
self.tools[tool.tool_id] = tool
return action
def cleanup(self):
# We need to make sure we set _default_mouse_mode to None otherwise
# we keep a reference to the viewer (parent) inside the mouse mode,
# creating a circular reference.
if self._default_mouse_mode is not None:
self._default_mouse_mode.deactivate()
self._default_mouse_mode = None
self.active_tool = None
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/data_viewer.py 0000644 0001750 0001750 00000015611 13605360406 023613 0 ustar noahfx noahfx from qtpy.QtCore import Qt
from qtpy import QtWidgets
from glue.core.qt.layer_artist_model import QtLayerArtistContainer, LayerArtistWidget
from glue.utils.qt import set_cursor, messagebox_on_error
from glue.core.qt.dialogs import warn
from glue.utils.noconflict import classmaker
from glue.config import viewer_tool
from glue.viewers.common.qt.base_widget import BaseQtViewerWidget
from glue.viewers.common.tool import SimpleToolMenu
from glue.viewers.common.qt.toolbar import BasicToolbar
from glue.viewers.common.viewer import Viewer
from glue.viewers.common.utils import get_viewer_tools
__all__ = ['DataViewer', 'get_viewer_tools']
class ToolbarInitializer(object):
"""
This is a meta-class which ensures that initialize_toolbar is always called
on DataViewer instances and sub-class instances after all the __init__ code
has been executed. We need to do this, because often the toolbar can only
be initialized after everything else (e.g. canvas, etc.) has been set up,
so we can't do it in DataViewer.__init__.
"""
def __call__(cls, *args, **kwargs):
obj = type.__call__(cls, *args, **kwargs)
obj.initialize_toolbar()
return obj
@viewer_tool
class SaveTool(SimpleToolMenu):
"""
A generic 'save/export' tool that plugins can register new save/export tools
with.
To register a new save/export option, add an entry to the viewer
``subtools['save']`` list.
"""
tool_id = 'save'
icon = 'glue_filesave'
tool_tip = 'Save/export the plot'
# Note: we need to use classmaker here because otherwise we run into issues when
# trying to use the meta-class with the Qt class.
class DataViewer(Viewer, BaseQtViewerWidget,
metaclass=classmaker(left_metas=(ToolbarInitializer,))):
"""
Base class for all Qt DataViewer widgets.
This defines a minimal interface, and implements the following::
* An automatic call to unregister on window close
* Drag and drop support for adding data
"""
_layer_artist_container_cls = QtLayerArtistContainer
_layer_style_widget_cls = None
_toolbar_cls = BasicToolbar
# This defines the mouse mode to be used when no toolbar modes are active
_default_mouse_mode_cls = None
inherit_tools = True
tools = ['save']
subtools = {'save': []}
_close_on_last_layer_removed = True
_options_cls = None
large_data_size = None
def __init__(self, session, state=None, parent=None):
"""
:type session: :class:`~glue.core.session.Session`
"""
BaseQtViewerWidget.__init__(self, parent)
Viewer.__init__(self, session, state=state)
self._view = LayerArtistWidget(layer_style_widget_cls=self._layer_style_widget_cls,
hub=session.hub)
self._view.layer_list.setModel(self._layer_artist_container.model)
# Set up the options widget, which will include options that control the
# viewer state
if self._options_cls is None:
self.options = QtWidgets.QWidget()
else:
self.options = self._options_cls(viewer_state=self.state,
session=session)
self._tb_vis = {} # store whether toolbars are enabled
self.toolbar = None
self._toolbars = []
self._warn_close = True
# close window when last plot layer deleted
if self._close_on_last_layer_removed:
self._layer_artist_container.on_empty(self._close_nowarn)
self._layer_artist_container.on_changed(self.update_window_title)
self.update_window_title()
@property
def selected_layer(self):
return self._view.layer_list.current_artist()
@set_cursor(Qt.WaitCursor)
def apply_roi(self, roi):
pass
def warn(self, message, *args, **kwargs):
return warn(message, *args, **kwargs)
def _close_nowarn(self):
return self.close(warn=False)
def closeEvent(self, event):
super(DataViewer, self).closeEvent(event)
Viewer.cleanup(self)
# We tell the toolbar to do cleanup to make sure we get rid of any
# circular references
if self.toolbar:
self.toolbar.cleanup()
def layer_view(self):
return self._view
def addToolBar(self, tb):
super(DataViewer, self).addToolBar(tb)
self._toolbars.append(tb)
self._tb_vis[tb] = True
def initialize_toolbar(self):
from glue.config import viewer_tool
self.toolbar = self._toolbar_cls(self, default_mouse_mode_cls=self._default_mouse_mode_cls)
# Need to include tools and subtools declared by parent classes unless
# specified otherwise
tool_ids, subtool_ids = get_viewer_tools(self.__class__)
for tool_id in tool_ids:
mode_cls = viewer_tool.members[tool_id]
if tool_id in subtool_ids:
subtools = []
for subtool_id in subtool_ids[tool_id]:
subtools.append(viewer_tool.members[subtool_id](self))
mode = mode_cls(self, subtools=subtools)
else:
mode = mode_cls(self)
self.toolbar.add_tool(mode)
self.addToolBar(self.toolbar)
self.toolbar_added.emit()
def show_toolbars(self):
"""
Re-enable any toolbars that were hidden with `hide_toolbars()`
Does not re-enable toolbars that were hidden by other means
"""
for tb in self._toolbars:
if self._tb_vis.get(tb, False):
tb.setEnabled(True)
def hide_toolbars(self):
"""
Disable all the toolbars in the viewer.
This action can be reversed by calling `show_toolbars()`
"""
for tb in self._toolbars:
self._tb_vis[tb] = self._tb_vis.get(tb, False) or tb.isVisible()
tb.setEnabled(False)
def set_focus(self, state):
super(DataViewer, self).set_focus(state)
if state:
self.show_toolbars()
else:
self.hide_toolbars()
def __gluestate__(self, context):
state = Viewer.__gluestate__(self, context)
state['size'] = self.viewer_size
state['pos'] = self.position
state['_protocol'] = 1
return state
def update_viewer_state(rec, context):
pass
@classmethod
def __setgluestate__(cls, rec, context):
if rec.get('_protocol', 0) < 1:
cls.update_viewer_state(rec, context)
viewer = super(DataViewer, cls).__setgluestate__(rec, context)
viewer.viewer_size = rec['size']
x, y = rec['pos']
viewer.move(x=x, y=y)
return viewer
@messagebox_on_error("Failed to add data")
def add_data(self, data):
return super(DataViewer, self).add_data(data)
@messagebox_on_error("Failed to add subset")
def add_subset(self, subset):
return super(DataViewer, self).add_subset(subset)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/base_widget.py 0000644 0001750 0001750 00000015154 13605360406 023600 0 ustar noahfx noahfx import os
from qtpy.QtCore import Qt
from qtpy import QtCore, QtWidgets
from glue.utils.qt import get_qapp
from glue.core.qt.mime import LAYERS_MIME_TYPE, LAYER_MIME_TYPE
__all__ = ['BaseQtViewerWidget']
class BaseQtViewerWidget(QtWidgets.QMainWindow):
"""
Base Qt class for all DataViewer widgets. This is not a viewer class in
itself but is the base widget that should be used for any Qt viewer that
is to appear inside the MDI area.
"""
window_closed = QtCore.Signal()
toolbar_added = QtCore.Signal()
_closed = False
def __init__(self, parent=None):
"""
:type session: :class:`~glue.core.session.Session`
"""
super(BaseQtViewerWidget, self).__init__(parent)
self.setWindowIcon(get_qapp().windowIcon())
status_bar = self.statusBar()
status_bar.setSizeGripEnabled(False)
status_bar.setStyleSheet("QStatusBar{font-size:10px}")
self.setFocusPolicy(Qt.StrongFocus)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setAcceptDrops(True)
self.setAnimated(False)
self.setContentsMargins(2, 2, 2, 2)
self._mdi_wrapper = None # GlueMdiSubWindow that self is embedded in
self._warn_close = True
def dragEnterEvent(self, event):
"""
Accept drag-and-drop of data or subset objects.
"""
if event.mimeData().hasFormat(LAYER_MIME_TYPE):
event.accept()
elif event.mimeData().hasFormat(LAYERS_MIME_TYPE):
event.accept()
else:
event.ignore()
def dropEvent(self, event):
"""
Accept drag-and-drop of data or subset objects.
"""
if event.mimeData().hasFormat(LAYER_MIME_TYPE):
self.request_add_layer(event.mimeData().data(LAYER_MIME_TYPE))
assert event.mimeData().hasFormat(LAYERS_MIME_TYPE)
for layer in event.mimeData().data(LAYERS_MIME_TYPE):
self.request_add_layer(layer)
event.accept()
def mousePressEvent(self, event):
"""
Consume mouse press events, and prevent them from propagating
down to the MDI area.
"""
event.accept()
def close(self, warn=True):
if self._closed:
return
if warn and not self._confirm_close():
return
self._warn_close = False
if getattr(self, '_mdi_wrapper', None) is not None:
self._mdi_wrapper.close()
self._mdi_wrapper = None
else:
try:
QtWidgets.QMainWindow.close(self)
except RuntimeError:
# In some cases the above can raise a "wrapped C/C++ object of
# type ... has been deleted" error, in which case we can just
# ignore and carry on.
pass
self._closed = True
def mdi_wrap(self):
"""
Wrap this object in a GlueMdiSubWindow
"""
from glue.app.qt.mdi_area import GlueMdiSubWindow
sub = GlueMdiSubWindow()
sub.setWidget(self)
self.destroyed.connect(sub.close)
sub.resize(self.size())
self._mdi_wrapper = sub
return sub
@property
def position(self):
"""
The location of the viewer as a tuple of ``(x, y)``
"""
target = self._mdi_wrapper or self
pos = target.pos()
return pos.x(), pos.y()
@position.setter
def position(self, xy):
x, y = xy
self.move(x, y)
def move(self, x=None, y=None):
"""
Move the viewer to a new XY pixel location
You can also set the position attribute to a new tuple directly.
Parameters
----------
x : int (optional)
New x position
y : int (optional)
New y position
"""
x0, y0 = self.position
if x is None:
x = x0
if y is None:
y = y0
if self._mdi_wrapper is not None:
self._mdi_wrapper.move(x, y)
else:
QtWidgets.QMainWindow.move(self, x, y)
@property
def viewer_size(self):
"""
Size of the viewer as a tuple of ``(width, height)``
"""
if self._mdi_wrapper is not None:
sz = self._mdi_wrapper.size()
else:
sz = self.size()
return sz.width(), sz.height()
@viewer_size.setter
def viewer_size(self, value):
width, height = value
if self._mdi_wrapper is None:
self.resize(width, height)
else:
self._mdi_wrapper.resize(width, height)
def closeEvent(self, event):
"""
Call unregister on window close
"""
if self._warn_close and not self._confirm_close():
event.ignore()
return
super(BaseQtViewerWidget, self).closeEvent(event)
event.accept()
self.window_closed.emit()
def isVisible(self):
# Override this so as to catch RuntimeError: wrapped C/C++ object of
# type ... has been deleted
try:
return self.isVisible()
except RuntimeError:
return False
def _confirm_close(self):
"""Ask for close confirmation
:rtype: bool. True if user wishes to close. False otherwise
"""
if self._warn_close and not os.environ.get('GLUE_TESTING'):
buttons = QtWidgets.QMessageBox.Ok | QtWidgets.QMessageBox.Cancel
dialog = QtWidgets.QMessageBox.warning(self, "Confirm Close",
"Do you want to close this window?",
buttons=buttons,
defaultButton=QtWidgets.QMessageBox.Cancel)
return dialog == QtWidgets.QMessageBox.Ok
return True
def layer_view(self):
return QtWidgets.QWidget()
def options_widget(self):
return QtWidgets.QWidget()
def set_focus(self, state):
if state:
css = """
DataViewer
{
border: 2px solid;
border-color: rgb(56, 117, 215);
}
"""
else:
css = """
DataViewer
{
border: none;
}
"""
self.setStyleSheet(css)
@property
def window_title(self):
return str(self)
def update_window_title(self):
try:
self.setWindowTitle(self.window_title)
except RuntimeError: # Avoid C/C++ errors when closing viewer
pass
def set_status(self, message):
sb = self.statusBar()
sb.showMessage(message)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/__init__.py 0000644 0001750 0001750 00000000000 13455362716 023053 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/tool.py 0000644 0001750 0001750 00000000300 13507416115 022263 0 ustar noahfx noahfx import warnings
from glue.viewers.common.tool import * # noqa
warnings.warn('glue.viewers.common.qt.tool is deprecated, use '
'glue.viewers.common.tool instead', UserWarning)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/data_slice_widget.py 0000644 0001750 0001750 00000016350 13657331513 024761 0 ustar noahfx noahfx import os
import numpy as np
from qtpy import QtCore, QtWidgets
from glue.utils.qt import load_ui
from glue.utils import nonpartial, format_minimal
from glue.icons.qt import get_icon
from glue.core.state_objects import State, CallbackProperty
from echo.qt import autoconnect_callbacks_to_qt
class SliceState(State):
label = CallbackProperty()
slider_label = CallbackProperty()
slider_unit = CallbackProperty()
slice_center = CallbackProperty()
use_world = CallbackProperty()
class SliceWidget(QtWidgets.QWidget):
slice_changed = QtCore.Signal(int)
def __init__(self, label='', world=None, lo=0, hi=10,
parent=None, world_unit=None,
world_warning=False):
super(SliceWidget, self).__init__(parent)
self.state = SliceState()
self.state.label = label
self.state.slice_center = (lo + hi) // 2
self._world = np.asarray(world)
self._world_warning = world_warning
self._world_unit = world_unit
self.ui = load_ui('data_slice_widget.ui', self,
directory=os.path.dirname(__file__))
self._connections = autoconnect_callbacks_to_qt(self.state, self.ui)
font = self.text_warning.font()
font.setPointSize(font.pointSize() * 0.75)
self.text_warning.setFont(font)
self.button_first.setStyleSheet('border: 0px')
self.button_first.setIcon(get_icon('playback_first'))
self.button_prev.setStyleSheet('border: 0px')
self.button_prev.setIcon(get_icon('playback_prev'))
self.button_back.setStyleSheet('border: 0px')
self.button_back.setIcon(get_icon('playback_back'))
self.button_stop.setStyleSheet('border: 0px')
self.button_stop.setIcon(get_icon('playback_stop'))
self.button_forw.setStyleSheet('border: 0px')
self.button_forw.setIcon(get_icon('playback_forw'))
self.button_next.setStyleSheet('border: 0px')
self.button_next.setIcon(get_icon('playback_next'))
self.button_last.setStyleSheet('border: 0px')
self.button_last.setIcon(get_icon('playback_last'))
self.value_slice_center.setMinimum(lo)
self.value_slice_center.setMaximum(hi)
self.value_slice_center.valueChanged.connect(nonpartial(self.set_label_from_slider))
# Figure out the optimal format to use to show the world values. We do
# this by figuring out the precision needed so that when converted to
# a string, every string value is different.
if world is not None and len(world) > 1:
self.label_fmt = format_minimal(world)[0]
else:
self.label_fmt = "{:g}"
self.text_slider_label.setMinimumWidth(80)
self.state.slider_label = self.label_fmt.format(self.value_slice_center.value())
self.text_slider_label.editingFinished.connect(nonpartial(self.set_slider_from_label))
self._play_timer = QtCore.QTimer()
self._play_timer.setInterval(500)
self._play_timer.timeout.connect(nonpartial(self._play_slice))
self.button_first.clicked.connect(nonpartial(self._browse_slice, 'first'))
self.button_prev.clicked.connect(nonpartial(self._browse_slice, 'prev'))
self.button_back.clicked.connect(nonpartial(self._adjust_play, 'back'))
self.button_stop.clicked.connect(nonpartial(self._adjust_play, 'stop'))
self.button_forw.clicked.connect(nonpartial(self._adjust_play, 'forw'))
self.button_next.clicked.connect(nonpartial(self._browse_slice, 'next'))
self.button_last.clicked.connect(nonpartial(self._browse_slice, 'last'))
self.bool_use_world.toggled.connect(nonpartial(self.set_label_from_slider))
if world is None:
self.state.use_world = False
self.bool_use_world.hide()
else:
self.state.use_world = not world_warning
if world_unit:
self.state.slider_unit = world_unit
else:
self.state.slider_unit = ''
self._play_speed = 0
self.set_label_from_slider()
def set_label_from_slider(self):
value = self.state.slice_center
if self.state.use_world:
value = self._world[value]
if self._world_warning:
self.text_warning.show()
else:
self.text_warning.hide()
self.state.slider_unit = self._world_unit
self.state.slider_label = self.label_fmt.format(value)
else:
self.text_warning.hide()
self.state.slider_unit = ''
self.state.slider_label = str(value)
def set_slider_from_label(self):
# Ignore recursive calls - we do this rather than ignore_callback
# below when setting slider_label, otherwise we might be stopping other
# subscribers to that event from being correctly updated
if getattr(self, '_in_set_slider_from_label', False):
return
else:
self._in_set_slider_from_label = True
text = self.text_slider_label.text()
if self.state.use_world:
# Don't want to assume world is sorted, pick closest value
value = np.argmin(np.abs(self._world - float(text)))
self.state.slider_label = self.label_fmt.format(self._world[value])
else:
value = int(text)
self.value_slice_center.setValue(value)
self._in_set_slider_from_label = False
def _adjust_play(self, action):
if action == 'stop':
self._play_speed = 0
elif action == 'back':
if self._play_speed > 0:
self._play_speed = -1
else:
self._play_speed -= 1
elif action == 'forw':
if self._play_speed < 0:
self._play_speed = +1
else:
self._play_speed += 1
if self._play_speed == 0:
self._play_timer.stop()
else:
self._play_timer.start()
self._play_timer.setInterval(500 / abs(self._play_speed))
def _play_slice(self):
if self._play_speed > 0:
self._browse_slice('next', play=True)
elif self._play_speed < 0:
self._browse_slice('prev', play=True)
def _browse_slice(self, action, play=False):
imin = self.value_slice_center.minimum()
imax = self.value_slice_center.maximum()
value = self.value_slice_center.value()
# If this was not called from _play_slice, we should stop the
# animation.
if not play:
self._adjust_play('stop')
if action == 'first':
value = imin
elif action == 'last':
value = imax
elif action == 'prev':
value = value - 1
if value < imin:
value = imax
elif action == 'next':
value = value + 1
if value > imax:
value = imin
else:
raise ValueError("Action should be one of first/prev/next/last")
self.value_slice_center.setValue(value)
if __name__ == "__main__":
from glue.utils.qt import get_qapp
app = get_qapp()
widget = SliceWidget(label='BANANA')
widget.show()
widget = SliceWidget(world=[1, 2, 3, 4, 5, 6, 7], lo=1, hi=7)
widget.show()
app.exec_()
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/contrastlimits.ui 0000644 0001750 0001750 00000010566 13455362716 024402 0 ustar noahfx noahfx
min_max
Qt::WindowModal
0
0
250
150
0
0
Dialog
false
false
3
-
-
6
-
0
35
Choose Intensity Limits
Qt::AlignHCenter|Qt::AlignTop
-
-
50
0
Low
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Data value to set to black
100
-
-
50
0
High
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Data value to set to white
100
-
Qt::Horizontal
QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok
buttonBox
accepted()
min_max
accept()
248
254
157
274
buttonBox
rejected()
min_max
reject()
316
260
286
274
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/data_slice_widget.ui 0000644 0001750 0001750 00000015423 13502206677 024747 0 ustar noahfx noahfx
Form
0
0
291
90
Form
0
0
-
-
75
true
Main label
-
Qt::Horizontal
40
20
-
Show real coordinates
true
false
-
color: rgb(255, 33, 28)
Warning: real coordinates are not aligned with pixel grid. The coordinate shown above is the value at the center of the slice.
Qt::AlignCenter
true
-
10
-
Qt::Horizontal
-
2
-
Qt::Horizontal
40
20
-
Go to first slice
<<
16
16
-
Go to previous slice
<
16
16
-
Play backwards (click multiple times to speed up)
<
16
16
-
Stop the playback
▪
16
16
-
Play forwards (click multiple times to speed up)
>
16
16
-
Go to next slice
>
16
16
true
-
Go to last slice
>>
16
16
-
Qt::Horizontal
40
20
-
50
16777215
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
TextLabel
glueviz-1.0.1+dfsg.orig/glue/viewers/common/qt/data_viewer_with_state.py 0000644 0001750 0001750 00000000217 13605357235 026050 0 ustar noahfx noahfx from glue.viewers.common.qt.data_viewer import DataViewer
__all__ = ['DataViewerWithState']
class DataViewerWithState(DataViewer):
pass
glueviz-1.0.1+dfsg.orig/glue/viewers/common/python_export.py 0000644 0001750 0001750 00000000514 13605357235 023621 0 ustar noahfx noahfx __all__ = ['code', 'serialize_options']
class code(str):
pass
def serialize_options(options):
result = []
for key, value in options.items():
if isinstance(value, code):
result.append(key + '=' + value)
else:
result.append(key + '=' + repr(value))
return ', '.join(result)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/state.py 0000644 0001750 0001750 00000002705 13657331513 022021 0 ustar noahfx noahfx from echo import CallbackProperty, ListCallbackProperty
from glue.core.state_objects import State
__all__ = ['ViewerState', 'LayerState']
class ViewerState(State):
"""
A base class for all viewer states.
"""
layers = ListCallbackProperty(docstring='A collection of all layers in the viewer')
@property
def layers_data(self):
return [layer_state.layer for layer_state in self.layers]
class LayerState(State):
"""
A base class for all layer states.
"""
layer = CallbackProperty(docstring='The :class:`~glue.core.data.Data` or '
':class:`~glue.core.subset.Subset` '
'represented by the layer')
zorder = CallbackProperty(0, docstring='A value used to indicate which '
'layers are shown in front of which '
'(larger zorder values are on top of '
'other layers)')
visible = CallbackProperty(True, docstring='Whether the layer is currently visible')
def __init__(self, viewer_state=None, **kwargs):
super(LayerState, self).__init__(**kwargs)
self.viewer_state = viewer_state
def __repr__(self):
if self.layer is None:
return "%s with layer unset" % (self.__class__.__name__)
else:
return "%s for %s" % (self.__class__.__name__, self.layer.label)
glueviz-1.0.1+dfsg.orig/glue/viewers/common/__init__.py 0000644 0001750 0001750 00000000000 13455362716 022427 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/common/layer_artist.py 0000644 0001750 0001750 00000005500 13661230662 023375 0 ustar noahfx noahfx from echo import keep_in_sync, CallbackProperty
from glue.core.layer_artist import LayerArtistBase
from glue.viewers.common.state import LayerState
from glue.core.message import LayerArtistVisibilityMessage
__all__ = ['LayerArtist']
class LayerArtist(LayerArtistBase):
zorder = CallbackProperty()
visible = CallbackProperty()
_layer_state_cls = LayerState
_python_exporter = None
def __init__(self, viewer_state, layer_state=None, layer=None):
super(LayerArtist, self).__init__(layer)
self._viewer_state = viewer_state
self.layer = layer or layer_state.layer
self.state = layer_state or self._layer_state_cls(viewer_state=viewer_state,
layer=self.layer)
if self.state not in self._viewer_state.layers:
self._viewer_state.layers.append(self.state)
self.zorder = self.state.zorder
self.visible = self.state.visible
self._sync_zorder = keep_in_sync(self, 'zorder', self.state, 'zorder')
self._sync_visible = keep_in_sync(self, 'visible', self.state, 'visible')
self.state.add_callback('visible', self._on_visibility_change)
self._reset_cache()
def _reset_cache(self):
self._last_viewer_state = {}
self._last_layer_state = {}
def _on_visibility_change(self, *args):
if self.state.layer is not None and self.state.layer.hub is not None:
self.state.layer.hub.broadcast(LayerArtistVisibilityMessage(self))
def __gluestate__(self, context):
return dict(state=context.id(self.state))
def pop_changed_properties(self):
"""
Return the names of properties on the viewer and layer state classes
that have changed since the last call.
Note that calling this method updates the underlying cache, so if it is
called immediately after being called a first time, it will return an
empty set the second time.
"""
# Figure out which attributes are different from before. Ideally we
# shouldn't need this but some methods in layer artists are called
# multiple times if an attribute is changed due to x_att changing then
# hist_x_min, hist_x_max, etc. This method is called pop because it
# returns the list of changed properties and resets the cache.
changed = set()
for key, value in self._viewer_state.as_dict().items():
if value != self._last_viewer_state.get(key, None):
changed.add(key)
for key, value in self.state.as_dict().items():
if value != self._last_layer_state.get(key, None):
changed.add(key)
self._last_viewer_state.update(self._viewer_state.as_dict())
self._last_layer_state.update(self.state.as_dict())
return changed
glueviz-1.0.1+dfsg.orig/glue/viewers/common/tool.py 0000644 0001750 0001750 00000004621 13605357235 021657 0 ustar noahfx noahfx # The classes in this file define toolbar tools. Mouse modes specifically
# are defined in mouse_modes.py
from glue.core.callback_property import CallbackProperty
__all__ = ['Tool', 'CheckableTool', 'DropdownTool', 'SimpleToolMenu']
class Tool(object):
"""
The base class for all toolbar tools.
All tools have the following attributes:
* icon : QIcon object
* tool_id : a short name for the tool
* action_text : the action title (used if the tool is made available in a menu)
* tool_tip : a tip that is shown when the user hovers over the icon
* status_tip : a tip that is shown in the status bar when the tool is active
* shortcut : keyboard shortcut to toggle the tool
"""
enabled = CallbackProperty(True)
icon = None
tool_id = None
action_text = None
tool_tip = None
status_tip = None
shortcut = None
def __init__(self, viewer=None):
self.viewer = viewer
if hasattr(self.viewer, 'window_closed'):
self.viewer.window_closed.connect(self._do_close)
def activate(self):
"""
Fired when the toolbar button is activated
"""
pass
def menu_actions(self):
"""
List of QtWidgets.QActions to be attached to this tool
as a context menu.
"""
return []
def _do_close(self, *args):
# We do this so that tools can override close
self.close()
def close(self):
if hasattr(self.viewer, 'window_closed'):
self.viewer.window_closed.disconnect(self._do_close)
self.viewer = None
class CheckableTool(Tool):
"""
A tool that is checkable.
When checked, the ``activate`` method is executed, and when unchecked, the
``deactivate`` method is executed.
"""
def activate(self):
"""
Fired when the toolbar button is activated
"""
pass
def deactivate(self):
"""
Fired when the toolbar button is deactivated
"""
pass
class DropdownTool(Tool):
"""
A base class for all tools that show a drop-down menu.
"""
def __init__(self, *args, **kwargs):
self.subtools = kwargs.pop('subtools', [])
super(DropdownTool, self).__init__(*args, **kwargs)
class SimpleToolMenu(DropdownTool):
"""
A base class for tools that have no action it themselves but show a dropdown
of other tools.
"""
pass
glueviz-1.0.1+dfsg.orig/glue/viewers/common/viewer.py 0000644 0001750 0001750 00000037324 13661230662 022205 0 ustar noahfx noahfx import os
import warnings
from IPython import get_ipython
from glue.core.hub import HubListener
from glue.core import BaseData, Subset
from glue.core import command
from glue.core.command import ApplySubsetState
from glue.core.state import save
from glue.core import message as msg
from glue.core.exceptions import IncompatibleDataException
from glue.core.state import lookup_class_with_patches
from echo import delay_callback
from glue.core.layer_artist import LayerArtistContainer
from glue.viewers.common.state import ViewerState
from glue.viewers.common.layer_artist import LayerArtist
from glue.config import layer_artist_maker
__all__ = ['BaseViewer', 'Viewer']
def get_layer_artist_from_registry(data, viewer):
"""
Check whether any plugins define an appropriate custom layer artist for
the specified data and viewer.
"""
for maker in layer_artist_maker.members:
layer_artist = maker.function(viewer, data)
if layer_artist is not None:
return layer_artist
class BaseViewer(HubListener):
"""
The base class for all viewers.
"""
LABEL = 'Override this'
def __init__(self, session):
self._session = session
self._data = session.data_collection
self._hub = None
def register_to_hub(self, hub):
self._hub = hub
@property
def session(self):
return self._session
def request_add_layer(self, layer):
""" Issue a command to add a layer """
cmd = command.AddLayer(layer=layer, viewer=self)
self._session.command_stack.do(cmd)
def add_layer(self, layer):
if isinstance(layer, BaseData):
self.add_data(layer)
elif isinstance(layer, Subset):
self.add_subset(layer)
def remove_layer(self, layer):
pass
def add_data(self, data):
raise NotImplementedError()
def add_subset(self, subset):
raise NotImplementedError()
def __str__(self):
return self.LABEL
def __gluestate__(self, context):
return dict(session=context.id(self._session))
@classmethod
def __setgluestate__(cls, rec, context):
session = context.object(rec['session'])
return cls(session)
def apply_subset_state(self, subset_state, override_mode=None):
cmd = ApplySubsetState(data_collection=self._data,
subset_state=subset_state,
override_mode=override_mode)
self._session.command_stack.do(cmd)
TEMPLATE_SCRIPT = """
# This script was produced by glue and can be used to further customize a
# particular plot.
### Package imports
{imports}
### Set up data
data_collection = load('{data}')
### Set up viewer
{header}
### Set up layers
{layers}
### Legend
{legend}
### Finalize viewer
{footer}
""".strip()
class Viewer(BaseViewer):
"""
A viewer class that uses a state class to represent the overall viewer
state, and uses layer artists and state classes to handle each dataset
and subset in the data viewer.
"""
# The LayerArtistContainer class/subclass to use
_layer_artist_container_cls = LayerArtistContainer
# The state class/subclass to use
_state_cls = ViewerState
_data_artist_cls = LayerArtist
_subset_artist_cls = LayerArtist
allow_duplicate_data = False
allow_duplicate_subset = False
large_data_size = None
def __init__(self, session, state=None):
super(Viewer, self).__init__(session)
# Set up the state which will contain everything needed to represent
# the current state of the viewer
self.state = state or self._state_cls()
self.state.data_collection = session.data_collection
# Create the layer artist container, which is the object in which
# we will add LayerArtist objects
self._layer_artist_container = self._layer_artist_container_cls()
# When layer artists are removed from the layer artist container, we
# need to make sure we remove matching layer states in the viewer state
# layers attribute.
self._layer_artist_container.on_changed(self._sync_state_layers)
# And vice-versa when layer states are removed from the viewer state, we
# need to keep the layer_artist_container in sync
self.state.add_callback('layers', self._sync_layer_artist_container, priority=10000)
self.state.add_callback('layers', self.draw_legend)
def draw_legend(self, *args):
pass
def _sync_state_layers(self, *args):
# Remove layer state objects that no longer have a matching layer
for layer_state in self.state.layers:
if layer_state.layer not in self._layer_artist_container:
self.state.layers.remove(layer_state)
def _sync_layer_artist_container(self, *args):
# Remove layer artists that no longer have a matching layer state
layer_states = set(layer_state.layer for layer_state in self.state.layers)
for layer_artist in self._layer_artist_container:
if layer_artist.layer not in layer_states:
self._layer_artist_container.remove(layer_artist)
def warn(self, message, *args, **kwargs):
warnings.warn(message)
return True
def add_data(self, data):
# Check if data already exists in viewer
if not self.allow_duplicate_data and data in self._layer_artist_container:
return True
if self.large_data_size is not None and data.size >= self.large_data_size:
proceed = self.warn('Add large data set?', 'Data set {0:s} has {1:d} points, and '
'may render slowly.'.format(data.label, data.size),
default='Cancel', setting='show_large_data_warning')
if not proceed:
return False
if data not in self.session.data_collection:
raise IncompatibleDataException("Data not in DataCollection")
# Create layer artist and add to container. First check whether any
# plugins want to make a custom layer artist.
layer = get_layer_artist_from_registry(data, self) or self.get_data_layer_artist(data)
if layer is None:
return False
self._layer_artist_container.append(layer)
layer.update()
# Add existing subsets to viewer
for subset in data.subsets:
self.add_subset(subset)
return True
def remove_data(self, data):
with delay_callback(self.state, 'layers'):
for layer_state in self.state.layers[::-1]:
if isinstance(layer_state.layer, BaseData):
if layer_state.layer is data:
self.state.layers.remove(layer_state)
else:
if layer_state.layer.data is data:
self.state.layers.remove(layer_state)
def get_data_layer_artist(self, layer=None, layer_state=None):
return self.get_layer_artist(self._data_artist_cls, layer=layer, layer_state=layer_state)
def get_subset_layer_artist(self, layer=None, layer_state=None):
return self.get_layer_artist(self._subset_artist_cls, layer=layer, layer_state=layer_state)
def get_layer_artist(self, cls, layer=None, layer_state=None):
return cls(self.state, layer=layer, layer_state=layer_state)
def add_subset(self, subset):
# Check if subset already exists in viewer
if not self.allow_duplicate_subset and subset in self._layer_artist_container:
return True
# Create layer artist and add to container. First check whether any
# plugins want to make a custom layer artist.
layer = get_layer_artist_from_registry(subset, self) or self.get_subset_layer_artist(subset)
if layer is None:
return False
self._layer_artist_container.append(layer)
layer.update()
return True
def remove_subset(self, subset):
if subset in self._layer_artist_container:
self._layer_artist_container.pop(subset)
def _add_subset(self, message):
self.add_subset(message.subset)
def _update_data(self, message):
if message.data in self._layer_artist_container:
for layer_artist in self._layer_artist_container:
if isinstance(layer_artist.layer, Subset):
if layer_artist.layer.data is message.data:
layer_artist.update()
else:
if layer_artist.layer is message.data:
layer_artist.update()
def _update_subset(self, message):
if message.attribute == 'style':
return
if message.subset in self._layer_artist_container:
for layer_artist in self._layer_artist_container[message.subset]:
layer_artist.update()
def _remove_subset(self, message):
self.remove_subset(message.subset)
def options_widget(self):
return self.options
def _subset_has_data(self, x):
return x.sender.data in self._layer_artist_container.layers
def _has_data_or_subset(self, x):
return x.sender in self._layer_artist_container.layers
def _remove_data(self, message):
self.remove_data(message.data)
def _is_appearance_settings(self, msg):
return ('BACKGROUND_COLOR' in msg.settings or
'FOREGROUND_COLOR' in msg.settings)
def register_to_hub(self, hub):
super(Viewer, self).register_to_hub(hub)
hub.subscribe(self, msg.SubsetCreateMessage,
handler=self._add_subset,
filter=self._subset_has_data)
hub.subscribe(self, msg.SubsetUpdateMessage,
handler=self._update_subset,
filter=self._has_data_or_subset)
hub.subscribe(self, msg.SubsetDeleteMessage,
handler=self._remove_subset,
filter=self._has_data_or_subset)
hub.subscribe(self, msg.NumericalDataChangedMessage,
handler=self._update_data,
filter=self._has_data_or_subset)
hub.subscribe(self, msg.DataCollectionDeleteMessage,
handler=self._remove_data)
hub.subscribe(self, msg.ComponentsChangedMessage,
handler=self._update_data,
filter=self._has_data_or_subset)
hub.subscribe(self, msg.ExternallyDerivableComponentsChangedMessage,
handler=self._update_data,
filter=self._has_data_or_subset)
hub.subscribe(self, msg.SettingsChangeMessage,
self._update_appearance_from_settings,
filter=self._is_appearance_settings)
hub.subscribe(self, msg.ComputationMessage,
self._update_computation,
filter=self._has_layer_artist)
hub.subscribe(self, msg.LayerArtistDisabledMessage,
self.draw_legend,
filter=self._has_layer_artist)
def _has_layer_artist(self, message):
return message.layer_artist in self.layers
def _update_computation(self, message=None):
pass
def _update_appearance_from_settings(self, message=None):
pass
def __gluestate__(self, context):
return dict(state=self.state.__gluestate__(context),
session=context.id(self._session),
layers=list(map(context.do, self.layers)),
_protocol=1)
@classmethod
def __setgluestate__(cls, rec, context):
session = context.object(rec['session'])
viewer_state = cls._state_cls.__setgluestate__(rec['state'], context)
viewer = cls(session, state=viewer_state)
viewer.register_to_hub(session.hub)
# Restore layer artists. Ideally we would delay instead of ignoring the
# callback here.
with viewer._layer_artist_container.ignore_callbacks():
for l in rec['layers']:
cls = lookup_class_with_patches(l.pop('_type'))
layer_state = context.object(l['state'])
layer_artist = viewer.get_layer_artist(cls, layer_state=layer_state)
layer_state.viewer_state = viewer.state
viewer._layer_artist_container.append(layer_artist)
viewer.draw_legend() # need to be called here because callbacks are ignored in previous step
return viewer
def cleanup(self):
if self._hub is not None:
self.unregister(self._hub)
self._layer_artist_container.clear_callbacks()
self._layer_artist_container.clear()
# Remove any references to the viewer in the IPython namespace. We use
# list() here to force an explicit copy since we are modifying the
# dictionary in-place
shell = get_ipython()
if shell is not None:
for key in list(shell.user_ns):
if shell.user_ns[key] is self:
shell.user_ns.pop(key)
def remove_layer(self, layer):
self._layer_artist_container.pop(layer)
@property
def layers(self):
"""Return a tuple of layers in this viewer.
A layer is a visual representation of a dataset or subset within
the viewer"""
return tuple(self._layer_artist_container)
def _script_header(self):
raise NotImplementedError()
def _script_legend(self):
return [], ""
def _script_footer(self):
raise NotImplementedError()
def export_as_script(self, filename):
data_filename = os.path.relpath(filename) + '.data'
save(data_filename, self.session.data_collection)
imports = ['from glue.core.state import load']
imports_header, header = self._script_header()
imports.extend(imports_header)
layers = ""
for ilayer, layer in enumerate(self.layers):
if layer.layer.label:
layers += '## Layer {0}: {1}\n\n'.format(ilayer + 1, layer.layer.label)
else:
layers += '## Layer {0}\n\n'.format(ilayer + 1)
if layer.visible and layer.enabled:
if isinstance(layer.layer, BaseData):
index = self.session.data_collection.index(layer.layer)
layers += "layer_data = data_collection[{0}]\n\n".format(index)
else:
dindex = self.session.data_collection.index(layer.layer.data)
sindex = layer.layer.data.subsets.index(layer.layer)
layers += ("layer_data = data_collection[{0}].subsets[{1}]\n\n"
.format(dindex, sindex))
imports_layer, layer_script = layer._python_exporter(layer)
if layer_script is None:
continue
imports.extend(imports_layer)
layers += layer_script.strip() + "\n"
imports_legend, legend = self._script_legend()
imports.extend(imports_legend)
imports_footer, footer = self._script_footer()
imports.extend(imports_footer)
imports = os.linesep.join(sorted(set(imports),
key=lambda s: s.strip('# ')))
# The sorting key is added keep together similar but commented imports
# Typical ex:
# matplotlib.use('Agg')
# # matplotlib.use('qt5Agg')
script = TEMPLATE_SCRIPT.format(data=os.path.basename(data_filename),
imports=imports.strip(),
header=header.strip(),
layers=layers.strip(),
legend=legend.strip(),
footer=footer.strip())
with open(filename, 'w') as f:
f.write(script)
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/ 0000755 0001750 0001750 00000000000 13752535025 020500 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/ 0000755 0001750 0001750 00000000000 13752535025 021124 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022266 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/test_python_export.py 0000644 0001750 0001750 00000027134 13752534424 026632 0 ustar noahfx noahfx import numpy as np
import matplotlib.pyplot as plt
from astropy.utils import NumpyRNGContext
from glue.core import Data, DataCollection
from glue.app.qt.application import GlueApplication
from glue.viewers.matplotlib.qt.tests.test_python_export import BaseTestExportPython, random_with_nan
from glue.viewers.scatter.qt import ScatterViewer
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_legend(self, tmpdir):
self.viewer.state.legend.visible = True
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_simple_visual_legend(self, tmpdir):
self.viewer.state.legend.visible = True
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_legend(self, tmpdir):
self.viewer.state.legend.visible = True
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_legend(self, tmpdir):
self.viewer.state.legend.visible = True
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, tol=1)
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_density_map_cmap_with_subset_legend(self, tmpdir):
self.viewer.state.legend.visible = True
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)
def test_density_map_change(self, tmpdir):
# Regression test for a bug that caused the density map to still
# be visible if using color-coding with the density map then
# switching to markers.
self.viewer.state.layers[0].density_map = True
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap = plt.cm.BuGn
self.viewer.state.layers[0].density_map = False
self.assert_same(tmpdir)
def test_simple_polar_plot(self, tmpdir):
self.viewer.state.plot_mode = 'polar'
self.viewer.state.x_att = self.data.id['c']
self.viewer.state.y_att = self.data.id['d']
self.assert_same(tmpdir)
def test_full_sphere(self, tmpdir):
self.viewer.state.plot_mode = 'aitoff'
self.viewer.state.x_att = self.data.id['c']
self.viewer.state.y_att = self.data.id['d']
self.assert_same(tmpdir)
self.viewer.state.plot_mode = 'hammer'
self.viewer.state.x_att = self.data.id['e']
self.viewer.state.y_att = self.data.id['f']
self.assert_same(tmpdir)
self.viewer.state.plot_mode = 'lambert'
self.viewer.state.x_att = self.data.id['g']
self.viewer.state.y_att = self.data.id['h']
self.assert_same(tmpdir)
self.viewer.state.plot_mode = 'mollweide'
self.viewer.state.x_att = self.data.id['a']
self.viewer.state.y_att = self.data.id['b']
self.assert_same(tmpdir)
def test_cmap_size_noncartesian(self, tmpdir):
self.viewer.state.layers[0].size_mode = 'Linear'
self.viewer.state.layers[0].cmap_mode = 'Linear'
for proj in ['polar', 'aitoff', 'hammer', 'lambert', 'mollweide']:
self.viewer.state.plot_mode = proj
self.assert_same(tmpdir)
def test_vectors_noncartesian(self, tmpdir):
for proj in ['polar', 'aitoff', 'hammer', 'lambert', 'mollweide']:
self.viewer.state.plot_mode = proj
self._vector_common(tmpdir)
def test_errorbarxy_noncartesian(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
for proj in ['polar', 'aitoff', 'hammer', 'lambert', 'mollweide']:
self.viewer.state.plot_mode = proj
self.assert_same(tmpdir)
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024372 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/data/ 0000755 0001750 0001750 00000000000 13752535025 023177 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/data/scatter_v0.glu 0000644 0001750 0001750 00000023057 13502206677 025772 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoAAAAAAADwP5qZmZmZmck/AAAAAAAA8L8="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoDAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAA="
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoAAAAAAAAQQJqZmZmZmdk/AAAAAAAAFEA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b",
"c"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0",
"Component_1"
],
"data": [
"basic"
],
"groups": [
"Subset 1_0",
"Subset 2_0"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0"
],
"subset_group_count": 2
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"PolygonalROI": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
0.010048309178743997,
0.22106280193236705,
0.22106280193236705,
0.010048309178743997,
0.010048309178743997
],
"vy": [
1.9849289099526066,
1.9849289099526066,
2.167298578199052,
2.167298578199052,
1.9849289099526066
]
},
"PolygonalROI_0": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
-1.04,
0.4521739130434783,
0.4521739130434783,
-1.04,
-1.04
],
"vy": [
1.9997156398104265,
1.9997156398104265,
2.2806635071090047,
2.2806635071090047,
1.9997156398104265
]
},
"RoiSubsetState": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI",
"xatt": "a",
"yatt": "b"
},
"RoiSubsetState_0": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI_0",
"xatt": "a",
"yatt": "b"
},
"ScatterWidget": {
"_type": "glue.viewers.scatter.qt.viewer_widget.ScatterWidget",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "basic",
"visible": true,
"xatt": "a",
"yatt": "b",
"zorder": 1
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 1",
"visible": true,
"xatt": "a",
"yatt": "b",
"zorder": 2
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 2",
"visible": true,
"xatt": "a",
"yatt": "b",
"zorder": 3
}
],
"pos": [
0,
0
],
"properties": {
"hidden": false,
"xatt": "a",
"xflip": false,
"xlog": false,
"xmax": 1.04,
"xmin": -1.04,
"yatt": "b",
"yflip": false,
"ylog": false,
"ymax": 3.02,
"ymin": 1.98
},
"session": "Session",
"size": [
600,
400
]
},
"ScatterWidget_0": {
"_type": "glue.viewers.scatter.qt.viewer_widget.ScatterWidget",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "basic",
"visible": true,
"xatt": "a",
"yatt": "c",
"zorder": 1
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 1",
"visible": false,
"xatt": "a",
"yatt": "c",
"zorder": 2
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 2",
"visible": true,
"xatt": "a",
"yatt": "c",
"zorder": 3
}
],
"pos": [
600,
0
],
"properties": {
"hidden": false,
"xatt": "a",
"xflip": false,
"xlog": true,
"xmax": 1.05,
"xmin": 9.5e-06,
"yatt": "c",
"yflip": false,
"ylog": true,
"ymax": 5.25,
"ymin": 0.38
},
"session": "Session",
"size": [
600,
400
]
},
"ScatterWidget_1": {
"_type": "glue.viewers.scatter.qt.viewer_widget.ScatterWidget",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "basic",
"visible": true,
"xatt": "b",
"yatt": "a",
"zorder": 1
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 1",
"visible": true,
"xatt": "b",
"yatt": "a",
"zorder": 2
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"layer": "Subset 2",
"visible": false,
"xatt": "b",
"yatt": "a",
"zorder": 3
}
],
"pos": [
0,
400
],
"properties": {
"hidden": false,
"xatt": "b",
"xflip": false,
"xlog": false,
"xmax": 5.0,
"xmin": 0.0,
"yatt": "a",
"yflip": true,
"ylog": false,
"ymax": 5.0,
"ymin": -5.0
},
"session": "Session",
"size": [
600,
400
]
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 1_0": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RoiSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1"
]
},
"Subset 2": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 2_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 2_0": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 2",
"state": "RoiSubsetState_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 2"
]
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.viewers.scatter"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ScatterWidget",
"ScatterWidget_0",
"ScatterWidget_1"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"basic": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
],
[
"c",
"Component_1"
]
],
"coords": "Coordinates",
"label": "basic",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b",
"c"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1",
"Subset 2"
],
"uuid": "dde080dc-a65a-4988-bed9-c0cb90ff91a8"
},
"c": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "c"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/data/scatter_and_line_v1.glu 0000644 0001750 0001750 00000016331 13644362032 027614 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ScatterLayerState"
]
},
"CallbackList_0": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ScatterLayerState_0"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoBAAAAAAAAAAIAAAAAAAAAAwAAAAAAAAA="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoCAAAAAAAAAAMAAAAAAAAABAAAAAAAAAA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0"
],
"data": [
"table"
],
"groups": [],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0"
],
"subset_group_count": 0
},
"LinearSegmentedColormap": {
"_type": "matplotlib.colors.LinearSegmentedColormap",
"cmap": "gray"
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"ScatterLayerState": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.7777777777777778,
"cmap": "LinearSegmentedColormap",
"cmap_att": "a",
"cmap_mode": "st__Fixed",
"cmap_vmax": 3.0,
"cmap_vmin": 1.0,
"color": "st__#404040",
"layer": "table",
"linestyle": "st__solid",
"linewidth": 1,
"size": 3,
"size_att": "a",
"size_mode": "st__Fixed",
"size_scaling": 1,
"size_vmax": 3.0,
"size_vmin": 1.0,
"style": "st__Scatter",
"visible": true,
"xerr_att": "a",
"xerr_visible": false,
"yerr_att": "a",
"yerr_visible": false,
"zorder": 1
}
},
"ScatterLayerState_0": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.7777777777777778,
"cmap": "LinearSegmentedColormap",
"cmap_att": "a",
"cmap_mode": "st__Fixed",
"cmap_vmax": 3.0,
"cmap_vmin": 1.0,
"color": "st__#404040",
"layer": "table",
"linestyle": "st__solid",
"linewidth": 1,
"size": 3,
"size_att": "a",
"size_mode": "st__Fixed",
"size_scaling": 1,
"size_vmax": 3.0,
"size_vmin": 1.0,
"style": "st__Line",
"visible": true,
"xerr_att": "a",
"xerr_visible": false,
"yerr_att": "a",
"yerr_visible": false,
"zorder": 1
}
},
"ScatterViewer": {
"_protocol": 1,
"_type": "glue.viewers.scatter.qt.data_viewer.ScatterViewer",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
605,
444
],
"state": {
"values": {
"aspect": "st__auto",
"layers": "CallbackList",
"x_att": "a",
"x_log": false,
"x_max": 3.0,
"x_min": 1.0,
"y_att": "b",
"y_log": false,
"y_max": 4.0,
"y_min": 2.0
}
}
},
"ScatterViewer_0": {
"_protocol": 1,
"_type": "glue.viewers.scatter.qt.data_viewer.ScatterViewer",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_0"
}
],
"pos": [
605,
0
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__auto",
"layers": "CallbackList_0",
"x_att": "a",
"x_log": false,
"x_max": 3.0,
"x_min": 1.0,
"y_att": "b",
"y_log": false,
"y_max": 4.0,
"y_min": 2.0
}
}
},
"Session": {
"_type": "glue.core.session.Session"
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.core.data_exporters",
"glue.viewers.histogram",
"glue.io.formats.fits",
"glue_exp.tools.zoom_buttons",
"glue.viewers.scatter",
"glue.plugins.export_d3po",
"glue.plugins.exporters.plotly",
"glue_samp",
"glue_exp.importers.webcam",
"glue.viewers.table",
"glue_aladin",
"glue.plugins.tools.spectrum_tool",
"glue_vispy_viewers.volume",
"glue.plugins.dendro_viewer",
"glue.viewers.image",
"glue_exp.tools.contour_selection",
"glue_wwt",
"glue.plugins.tools.pv_slicer",
"glue_exp.tools.floodfill_selection",
"glue_exp.importers.vizier",
"glue_vispy_viewers.scatter",
"glue.plugins.coordinate_helpers"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ScatterViewer",
"ScatterViewer_0"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"table": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "table",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.7777777777777778,
"color": "#404040",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [],
"uuid": "3755b390-c67e-44a0-b5b5-ebfc709c859e"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/data/scatter_v1.glu 0000644 0001750 0001750 00000031273 13644362032 025765 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ScatterLayerState",
"ScatterLayerState_0",
"ScatterLayerState_1"
]
},
"CallbackList_0": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ScatterLayerState_2",
"ScatterLayerState_3",
"ScatterLayerState_4"
]
},
"CallbackList_1": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ScatterLayerState_5",
"ScatterLayerState_6",
"ScatterLayerState_7"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoAAAAAAADwP5qZmZmZmck/AAAAAAAA8L8="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoDAAAAAAAAAAIAAAAAAAAAAgAAAAAAAAA="
},
"units": ""
},
"Component_1": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsKSwgfSAgICAgICAgICAgIAoAAAAAAAAQQJqZmZmZmdk/AAAAAAAAFEA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b",
"c"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0",
"Component_1"
],
"data": [
"basic"
],
"groups": [
"Subset 1",
"Subset 2"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2"
],
"subset_group_count": 2
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"PolygonalROI": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
0.010048309178743997,
0.22106280193236705,
0.22106280193236705,
0.010048309178743997,
0.010048309178743997
],
"vy": [
1.9849289099526066,
1.9849289099526066,
2.167298578199052,
2.167298578199052,
1.9849289099526066
]
},
"PolygonalROI_0": {
"_type": "glue.core.roi.PolygonalROI",
"vx": [
-1.04,
0.4521739130434783,
0.4521739130434783,
-1.04,
-1.04
],
"vy": [
1.9997156398104265,
1.9997156398104265,
2.2806635071090047,
2.2806635071090047,
1.9997156398104265
]
},
"RoiSubsetState": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI",
"xatt": "a",
"yatt": "b"
},
"RoiSubsetState_0": {
"_type": "glue.core.subset.RoiSubsetState",
"roi": "PolygonalROI_0",
"xatt": "a",
"yatt": "b"
},
"ScatterLayerState": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "basic",
"size": 3,
"visible": true,
"zorder": 2
}
},
"ScatterLayerState_0": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"size": 7,
"visible": true,
"zorder": 3
}
},
"ScatterLayerState_1": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#33a02c",
"layer": "Subset 2_0",
"size": 7,
"visible": true,
"zorder": 4
}
},
"ScatterLayerState_2": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "basic",
"size": 3,
"visible": true,
"zorder": 2
}
},
"ScatterLayerState_3": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"size": 7,
"visible": false,
"zorder": 3
}
},
"ScatterLayerState_4": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#33a02c",
"layer": "Subset 2_0",
"size": 7,
"visible": true,
"zorder": 4
}
},
"ScatterLayerState_5": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "basic",
"size": 3,
"visible": true,
"zorder": 2
}
},
"ScatterLayerState_6": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"size": 7,
"visible": true,
"zorder": 3
}
},
"ScatterLayerState_7": {
"_type": "glue.viewers.scatter.state.ScatterLayerState",
"values": {
"alpha": 0.5,
"color": "st__#33a02c",
"layer": "Subset 2_0",
"size": 7,
"visible": false,
"zorder": 4
}
},
"ScatterViewer": {
"_protocol": 1,
"_type": "glue.viewers.scatter.qt.data_viewer.ScatterViewer",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_0"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_1"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"layers": "CallbackList",
"x_att": "a",
"x_log": false,
"x_max": 1.04,
"x_min": -1.04,
"y_att": "b",
"y_log": false,
"y_max": 3.02,
"y_min": 1.98
}
}
},
"ScatterViewer_0": {
"_protocol": 1,
"_type": "glue.viewers.scatter.qt.data_viewer.ScatterViewer",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_2"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_3"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_4"
}
],
"pos": [
600,
0
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"layers": "CallbackList_0",
"x_att": "a",
"x_log": true,
"x_max": 1.05,
"x_min": 9.5e-06,
"y_att": "c",
"y_log": true,
"y_max": 5.25,
"y_min": 0.38
}
}
},
"ScatterViewer_1": {
"_protocol": 1,
"_type": "glue.viewers.scatter.qt.data_viewer.ScatterViewer",
"layers": [
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_5"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_6"
},
{
"_type": "glue.viewers.scatter.layer_artist.ScatterLayerArtist",
"state": "ScatterLayerState_7"
}
],
"pos": [
0,
400
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"layers": "CallbackList_1",
"x_att": "b",
"x_log": false,
"x_max": 5.0,
"x_min": 0.0,
"y_att": "a",
"y_log": false,
"y_max": 5.0,
"y_min": -5.0
}
}
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RoiSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1_0"
]
},
"Subset 1_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 2": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 2",
"state": "RoiSubsetState_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 2_0"
]
},
"Subset 2_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 2",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue.plugins.exporters.plotly",
"specviz.app",
"glue.plugins.coordinate_helpers",
"glue.viewers.histogram",
"glue.core.data_exporters",
"glue.plugins.export_d3po",
"glue_vispy_viewers.volume",
"glue_vispy_viewers.scatter",
"glue.viewers.table",
"glue.viewers.image",
"glue_medical",
"glue.plugins.tools.spectrum_tool",
"glue.plugins.tools.pv_slicer",
"glue.viewers.scatter"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ScatterViewer",
"ScatterViewer_0",
"ScatterViewer_1"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"basic": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
],
[
"c",
"Component_1"
]
],
"coords": "Coordinates",
"label": "basic",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b",
"c"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1_0",
"Subset 2_0"
],
"uuid": "dde080dc-a65a-4988-bed9-c0cb90ff91a8"
},
"c": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "c"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000110706 13752534424 026200 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import os
from collections import Counter
import pytest
import numpy as np
from numpy.testing import assert_allclose, assert_equal
from glue.config import colormaps
from glue.core.message import SubsetUpdateMessage
from glue.core import HubListener, Data
from glue.core.roi import XRangeROI, RectangularROI, CircularROI
from glue.core.roi_pretransforms import ProjectionMplTransform
from glue.core.subset import RoiSubsetState, AndState
from glue import core
from glue.core.component_id import ComponentID
from glue.utils.qt import combo_as_string, process_events
from glue.viewers.matplotlib.qt.tests.test_data_viewer import BaseTestMatplotlibDataViewer
from glue.core.state import GlueUnSerializer
from glue.app.qt.layer_tree_widget import LayerTreeWidget
from glue.app.qt import GlueApplication
from ..data_viewer import ScatterViewer
DATA = os.path.join(os.path.dirname(__file__), 'data')
fullsphere_projections = ['aitoff', 'hammer', 'lambert', 'mollweide']
class TestScatterCommon(BaseTestMatplotlibDataViewer):
def init_data(self):
return Data(label='d1', x=[3.4, 2.3, -1.1, 0.3], y=['a', 'b', 'c', 'a'])
viewer_cls = ScatterViewer
class TestScatterViewer(object):
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 teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_basic(self):
viewer_state = self.viewer.state
# Check defaults when we add data
self.viewer.add_data(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:z:Coordinate components:Pixel Axis 0 [x]'
assert combo_as_string(self.viewer.options_widget().ui.combosel_y_att) == 'Main components:x:y:z:Coordinate components:Pixel Axis 0 [x]'
assert viewer_state.x_att is self.data.id['x']
assert_allclose(viewer_state.x_min, -1.1 - 0.18)
assert_allclose(viewer_state.x_max, 3.4 + 0.18)
assert viewer_state.y_att is self.data.id['y']
assert_allclose(viewer_state.y_min, 3.2 - 0.012)
assert_allclose(viewer_state.y_max, 3.5 + 0.012)
assert not viewer_state.x_log
assert not viewer_state.y_log
assert len(viewer_state.layers) == 1
# Change to categorical component and check new values
viewer_state.y_att = self.data.id['z']
assert viewer_state.x_att is self.data.id['x']
assert_allclose(viewer_state.x_min, -1.1 - 0.18)
assert_allclose(viewer_state.x_max, 3.4 + 0.18)
assert viewer_state.y_att is self.data.id['z']
assert_allclose(viewer_state.y_min, -0.5 - 0.12)
assert_allclose(viewer_state.y_max, 2.5 + 0.12)
assert not viewer_state.x_log
assert not viewer_state.y_log
def test_flip(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
assert_allclose(viewer_state.x_min, -1.1 - 0.18)
assert_allclose(viewer_state.x_max, 3.4 + 0.18)
self.viewer.options_widget().button_flip_x.click()
assert_allclose(viewer_state.x_max, -1.1 - 0.18)
assert_allclose(viewer_state.x_min, 3.4 + 0.18)
assert_allclose(viewer_state.y_min, 3.2 - 0.012)
assert_allclose(viewer_state.y_max, 3.5 + 0.012)
self.viewer.options_widget().button_flip_y.click()
assert_allclose(viewer_state.y_max, 3.2 - 0.012)
assert_allclose(viewer_state.y_min, 3.5 + 0.012)
def test_remove_data(self):
self.viewer.add_data(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:z:Coordinate components:Pixel Axis 0 [x]'
assert combo_as_string(self.viewer.options_widget().ui.combosel_y_att) == 'Main components:x:y:z:Coordinate components:Pixel Axis 0 [x]'
self.data_collection.remove(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == ''
assert combo_as_string(self.viewer.options_widget().ui.combosel_y_att) == ''
def test_update_component_updates_title(self):
self.viewer.add_data(self.data)
assert self.viewer.windowTitle() == '2D Scatter'
self.viewer.state.x_att = self.data.id['y']
assert self.viewer.windowTitle() == '2D Scatter'
def test_combo_updates_with_component_add(self):
self.viewer.add_data(self.data)
self.data.add_component([3, 4, 1, 2], 'a')
assert self.viewer.state.x_att is self.data.id['x']
assert self.viewer.state.y_att is self.data.id['y']
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:z:a:Coordinate components:Pixel Axis 0 [x]'
assert combo_as_string(self.viewer.options_widget().ui.combosel_y_att) == 'Main components:x:y:z:a:Coordinate components:Pixel Axis 0 [x]'
def test_nonnumeric_first_component(self):
# regression test for #208. Shouldn't complain if
# first component is non-numerical
data = core.Data()
data.add_component(['a', 'b', 'c'], label='c1')
data.add_component([1, 2, 3], label='c2')
self.data_collection.append(data)
self.viewer.add_data(data)
def test_apply_roi(self):
self.viewer.add_data(self.data)
roi = RectangularROI(0, 3, 3.25, 3.45)
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert len(self.data.subsets) == 1
assert_allclose(self.data.subsets[0].to_mask(), [0, 1, 0, 0])
state = self.data.subsets[0].subset_state
assert isinstance(state, RoiSubsetState)
def test_apply_roi_categorical(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
viewer_state.y_att = self.data.id['z']
roi = RectangularROI(0, 3, -0.4, 0.3)
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert len(self.data.subsets) == 1
assert_allclose(self.data.subsets[0].to_mask(), [0, 0, 0, 1])
state = self.data.subsets[0].subset_state
assert isinstance(state, AndState)
def test_apply_roi_empty(self):
# Make sure that doing an ROI selection on an empty viewer doesn't
# produce error messsages
roi = XRangeROI(-0.2, 0.1)
self.viewer.apply_roi(roi)
def test_axes_labels(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
assert self.viewer.axes.get_xlabel() == 'x'
assert self.viewer.axes.get_ylabel() == 'y'
viewer_state.x_log = True
assert self.viewer.axes.get_xlabel() == 'Log x'
assert self.viewer.axes.get_ylabel() == 'y'
viewer_state.x_att = self.data.id['y']
assert self.viewer.axes.get_xlabel() == 'y'
assert self.viewer.axes.get_ylabel() == 'y'
viewer_state.y_log = True
assert self.viewer.axes.get_xlabel() == 'y'
assert self.viewer.axes.get_ylabel() == 'Log y'
def test_component_replaced(self):
# regression test for 508 - if a component ID is replaced, we should
# make sure that the component ID is selected if the old component ID
# was selected
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['x']
test = ComponentID('test')
self.data.update_id(self.viewer.state.x_att, test)
assert self.viewer.state.x_att is test
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:test:y:z:Coordinate components:Pixel Axis 0 [x]'
def test_nan_component(self):
# regression test for case when all values are NaN in a component
data = core.Data()
data.add_component([np.nan, np.nan, np.nan], label='c1')
self.data_collection.append(data)
self.viewer.add_data(data)
def test_density_map(self):
kwargs = dict(range=[(-5, 5), (-5, 5)], bins=(2, 2))
self.viewer.add_data(self.data)
self.viewer.state.layers[0].points_mode = 'auto'
assert self.viewer.layers[0].state.compute_density_map(**kwargs).sum() == 0
self.viewer.state.layers[0].points_mode = 'density'
assert self.viewer.layers[0].state.compute_density_map(**kwargs).sum() == 4
self.viewer.state.layers[0].points_mode = 'markers'
assert self.viewer.layers[0].state.compute_density_map(**kwargs).sum() == 0
def test_density_map_color(self):
# Regression test to make sure things don't crash when changing
# back to markers if the color mode is cmap
self.viewer.add_data(self.data)
self.viewer.state.layers[0].points_mode = 'density'
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].size_mode = 'Linear'
self.viewer.state.layers[0].points_mode = 'markers'
self.viewer.state.layers[0].points_mode = 'density'
@pytest.mark.parametrize('protocol', [0, 1])
def test_session_back_compat(self, protocol):
filename = os.path.join(DATA, 'scatter_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'basic'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 3
assert viewer1.state.x_att is dc[0].id['a']
assert viewer1.state.y_att is dc[0].id['b']
assert_allclose(viewer1.state.x_min, -1.04)
assert_allclose(viewer1.state.x_max, 1.04)
assert_allclose(viewer1.state.y_min, 1.98)
assert_allclose(viewer1.state.y_max, 3.02)
assert not viewer1.state.x_log
assert not viewer1.state.y_log
assert viewer1.state.layers[0].visible
assert viewer1.state.layers[1].visible
assert viewer1.state.layers[2].visible
viewer2 = ga.viewers[0][1]
assert len(viewer2.state.layers) == 3
assert viewer2.state.x_att is dc[0].id['a']
assert viewer2.state.y_att is dc[0].id['c']
assert_allclose(viewer2.state.x_min, 9.5e-6)
assert_allclose(viewer2.state.x_max, 1.05)
assert_allclose(viewer2.state.y_min, 0.38)
assert_allclose(viewer2.state.y_max, 5.25)
assert viewer2.state.x_log
assert viewer2.state.y_log
assert viewer2.state.layers[0].visible
assert not viewer2.state.layers[1].visible
assert viewer2.state.layers[2].visible
viewer3 = ga.viewers[0][2]
assert len(viewer3.state.layers) == 3
assert viewer3.state.x_att is dc[0].id['b']
assert viewer3.state.y_att is dc[0].id['a']
assert_allclose(viewer3.state.x_min, 0)
assert_allclose(viewer3.state.x_max, 5)
assert_allclose(viewer3.state.y_min, -5)
assert_allclose(viewer3.state.y_max, 5)
assert not viewer3.state.x_log
assert not viewer3.state.y_log
assert viewer3.state.layers[0].visible
assert viewer3.state.layers[1].visible
assert not viewer3.state.layers[2].visible
ga.close()
def test_session_line_back_compat(self):
# Backward-compatibility for v0.11 files in which the line and scatter
# plots were defined as separate styles.
filename = os.path.join(DATA, 'scatter_and_line_v1.glu')
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'table'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 1
assert viewer1.state.x_att is dc[0].id['a']
assert viewer1.state.y_att is dc[0].id['b']
assert viewer1.state.layers[0].markers_visible
assert not viewer1.state.layers[0].line_visible
viewer1 = ga.viewers[0][1]
assert len(viewer1.state.layers) == 1
assert viewer1.state.x_att is dc[0].id['a']
assert viewer1.state.y_att is dc[0].id['b']
assert not viewer1.state.layers[0].markers_visible
assert viewer1.state.layers[0].line_visible
ga.close()
def test_save_svg(self, tmpdir):
# Regression test for a bug in AxesCache that caused SVG saving to
# fail (because renderer.buffer_rgba did not exist)
self.viewer.add_data(self.data)
filename = tmpdir.join('test.svg').strpath
self.viewer.axes.figure.savefig(filename)
def test_2d(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data_2d)
assert viewer_state.x_att is self.data_2d.id['a']
assert_allclose(viewer_state.x_min, 1 - 0.12)
assert_allclose(viewer_state.x_max, 4 + 0.12)
assert viewer_state.y_att is self.data_2d.id['b']
assert_allclose(viewer_state.y_min, 5 - 0.12)
assert_allclose(viewer_state.y_max, 8 + 0.12)
assert self.viewer.layers[0].plot_artist.get_xdata().shape == (4,)
def test_apply_roi_single(self):
# Regression test for a bug that caused mode.update to be called
# multiple times and resulted in all other viewers receiving many
# messages regarding subset updates (this occurred when multiple)
# datasets were present.
layer_tree = LayerTreeWidget(session=self.session)
layer_tree.set_checkable(False)
layer_tree.setup(self.data_collection)
layer_tree.bind_selection_to_edit_subset()
class Client(HubListener):
def __init__(self, *args, **kwargs):
super(Client, self).__init__(*args, **kwargs)
self.count = Counter()
def ping(self, message):
self.count[message.sender] += 1
def register_to_hub(self, hub):
hub.subscribe(self, SubsetUpdateMessage, handler=self.ping)
d1 = Data(a=[1, 2, 3], label='d3')
d2 = Data(b=[1, 2, 3], label='d4')
d3 = Data(c=[1, 2, 3], label='d5')
d4 = Data(d=[1, 2, 3], label='d6')
self.data_collection.append(d1)
self.data_collection.append(d2)
self.data_collection.append(d3)
self.data_collection.append(d4)
client = Client()
client.register_to_hub(self.hub)
self.viewer.add_data(d1)
self.viewer.add_data(d3)
roi = XRangeROI(2.5, 3.5)
self.viewer.apply_roi(roi)
for subset in client.count:
assert client.count[subset] == 1
@pytest.mark.parametrize('ndim', [1, 2])
def test_all_options(self, ndim):
# This test makes sure that all the code for the different scatter modes
# gets run, though does not check the result.
viewer_state = self.viewer.state
if ndim == 1:
data = self.data
elif ndim == 2:
data = self.data_2d
self.viewer.add_data(data)
layer_state = viewer_state.layers[0]
layer_state.style = 'Scatter'
layer_state.size_mode = 'Linear'
layer_state.size_att = data.id['y']
layer_state.size_vmin = 1.2
layer_state.size_vmax = 4.
layer_state.size_scaling = 2
layer_state.cmap_mode = 'Linear'
layer_state.cmap_att = data.id['x']
layer_state.cmap_vmin = -1
layer_state.cmap_vmax = 2.
layer_state.cmap = colormaps.members[3][1]
# Check inverting works
layer_state.cmap_vmin = 3.
layer_state.size_mode = 'Fixed'
layer_state.xerr_visible = True
layer_state.xerr_att = data.id['x']
layer_state.yerr_visible = True
layer_state.yerr_att = data.id['y']
layer_state.style = 'Line'
layer_state.linewidth = 3
layer_state.linestyle = 'dashed'
def test_session_categorical(self, tmpdir):
def visible_xaxis_labels(ax):
# Due to a bug in Matplotlib the labels returned outside the field
# of view may be incorrect: https://github.com/matplotlib/matplotlib/issues/9397
pos = ax.xaxis.get_ticklocs()
labels = [tick.get_text() for tick in ax.xaxis.get_ticklabels()]
xmin, xmax = ax.get_xlim()
return [labels[i] for i in range(len(pos)) if pos[i] >= xmin and pos[i] <= xmax]
# Regression test for a bug that caused a restored scatter viewer
# with a categorical component to not show the categorical labels
# as tick labels.
filename = tmpdir.join('test_session_categorical.glu').strpath
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['z']
process_events()
assert visible_xaxis_labels(self.viewer.axes) == ['a', 'b', 'c']
self.session.application.save_session(filename)
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
viewer = ga.viewers[0][0]
assert viewer.state.x_att is dc[0].id['z']
assert visible_xaxis_labels(self.viewer.axes) == ['a', 'b', 'c']
ga.close()
def test_enable_disable_components_combo(self):
# Regression test for a bug that caused an error when turning off pixel
# components from combo boxes.
self.viewer.add_data(self.data)
self.data['a'] = self.data.id['x'] + 5
self.viewer.state.x_att_helper.pixel_coord = True
self.viewer.state.x_att = self.data.pixel_component_ids[0]
self.viewer.state.x_att_helper.pixel_coord = False
def test_datetime64_support(self, tmpdir):
self.data.add_component(np.array([100, 200, 300, 400], dtype='M8[D]'), 't1')
self.data.add_component(np.array([200, 300, 400, 500], dtype='M8[D]'), 't2')
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['t1']
self.viewer.state.y_att = self.data.id['y']
# Matplotlib deals with dates by converting them to the number of days
# since 01-01-0001, so we can check that the limits are correctly
# converted (and not 100 to 400)
assert self.viewer.axes.get_xlim() == (719251.0, 719575.0)
assert self.viewer.axes.get_ylim() == (3.2 - 0.012, 3.5 + 0.012)
# Apply an ROI selection in plotting coordinates
roi = RectangularROI(xmin=719313, xmax=719513, ymin=3, ymax=4)
self.viewer.apply_roi(roi)
# Check that the two middle elements are selected
assert_equal(self.data.subsets[0].to_mask(), [0, 1, 1, 0])
# Now do the same with the y axis
self.viewer.state.y_att = self.data.id['t2']
assert self.viewer.axes.get_xlim() == (719251.0, 719575.0)
assert self.viewer.axes.get_ylim() == (719351.0, 719675.0)
# Apply an ROI selection in plotting coordinates
edit = self.session.edit_subset_mode
edit.edit_subset = []
roi = CircularROI(xc=719463, yc=719563, radius=200)
self.viewer.apply_roi(roi)
assert_equal(self.data.subsets[1].to_mask(), [0, 1, 1, 1])
# Make sure that the Qt labels look ok
self.viewer.state.y_att = self.data.id['y']
options = self.viewer.options_widget().ui
assert options.valuetext_x_min.text() == '1970-03-30'
assert options.valuetext_x_max.text() == '1971-02-17'
assert options.valuetext_y_min.text() == '3.188'
assert options.valuetext_y_max.text() == '3.512'
# Make sure that we can set the xmin/xmax to a string date
assert_equal(self.viewer.state.x_min, np.datetime64('1970-03-30', 'D'))
options.valuetext_x_min.setText('1970-04-14')
options.valuetext_x_min.editingFinished.emit()
assert self.viewer.axes.get_xlim() == (719266.0, 719575.0)
assert_equal(self.viewer.state.x_min, np.datetime64('1970-04-14', 'D'))
# Make sure that everything works fine after saving/reloading
filename = tmpdir.join('test_datetime64.glu').strpath
self.session.application.save_session(filename)
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
viewer = ga.viewers[0][0]
options = viewer.options_widget().ui
assert_equal(self.viewer.state.x_min, np.datetime64('1970-04-14', 'D'))
assert options.valuetext_x_min.text() == '1970-04-14'
assert options.valuetext_x_max.text() == '1971-02-17'
assert options.valuetext_y_min.text() == '3.188'
assert options.valuetext_y_max.text() == '3.512'
ga.close()
def test_datetime64_disabled(self, capsys):
# Make sure that datetime components aren't options for the vector and
# error markers.
data = Data(label='test')
data.add_component(np.array([100, 200, 300, 400], dtype='M8[D]'), 't1')
data.add_component(np.array([200, 300, 400, 500], dtype='M8[D]'), 't2')
data.add_component(np.array([200., 300., 400., 500.]), 'x')
data.add_component(np.array([200., 300., 400., 500.]), 'y')
self.data_collection.append(data)
self.viewer.add_data(data)
self.viewer.state.x_att = data.id['x']
self.viewer.state.y_att = data.id['y']
self.viewer.state.layers[0].cmap_mode = 'Linear'
self.viewer.state.layers[0].cmap_att = data.id['x']
self.viewer.state.layers[0].size_mode = 'Linear'
self.viewer.state.layers[0].size_att = data.id['y']
self.viewer.state.layers[0].vector_visible = True
self.viewer.state.layers[0].xerr_visible = True
self.viewer.state.layers[0].yerr_visible = True
process_events()
self.viewer.state.x_att = data.id['t1']
self.viewer.state.y_att = data.id['t2']
process_events()
# We use capsys here because the # error is otherwise only apparent in stderr.
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
def test_density_map_incompatible_subset(self, capsys):
# Regression test for a bug that caused the scatter viewer to crash
# if subset for density map was incompatible.
data2 = 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_collection.append(data2)
self.viewer.add_data(self.data)
self.viewer.add_data(data2)
self.data_collection.new_subset_group('test', self.data.id['x'] > 1)
for layer in self.viewer.state.layers:
layer.density_map = True
self.viewer.figure.canvas.draw()
process_events()
assert self.viewer.layers[0].enabled
assert not self.viewer.layers[1].enabled
assert self.viewer.layers[2].enabled
assert not self.viewer.layers[3].enabled
def test_density_map_line_error_vector(self, capsys):
# Make sure that we don't allow/show lines/errors/vectors
# if in density map mode.
self.viewer.add_data(self.data)
self.viewer.state.layers[0].line_visible = True
self.viewer.state.layers[0].xerr_visible = True
self.viewer.state.layers[0].yerr_visible = True
self.viewer.state.layers[0].vector_visible = True
# Setting density_map to True resets the visibility of
# lines/errors/vectors.
self.viewer.state.layers[0].density_map = True
assert not self.viewer.state.layers[0].line_visible
assert not self.viewer.state.layers[0].xerr_visible
assert not self.viewer.state.layers[0].yerr_visible
assert not self.viewer.state.layers[0].vector_visible
def test_legend(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
viewer_state.legend.visible = True
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 1
assert labels[0] == 'd1'
self.data_collection.new_subset_group('test', self.data.id['x'] > 1)
assert len(viewer_state.layers) == 2
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 2
assert labels[1] == 'test'
print(handles[1][0])
# assert handles[1][0].get_color() == viewer_state.layers[1].state.color
# Add a non visible layer
data2 = Data(label='d2', x=[3.4, 2.3, -1.1, 0.3], y=[3.2, 3.3, 3.4, 3.5])
self.data_collection.append(data2)
self.viewer.add_data(data2)
assert len(viewer_state.layers) == 4
# 'd2' is not enabled (no linked component)
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 2
def test_changing_plot_modes(self):
viewer_state = self.viewer.state
viewer_state.plot_mode = 'polar'
assert 'polar' in str(type(self.viewer.axes)).lower()
viewer_state.plot_mode = 'aitoff'
assert 'aitoff' in str(type(self.viewer.axes)).lower()
viewer_state.plot_mode = 'hammer'
assert 'hammer' in str(type(self.viewer.axes)).lower()
viewer_state.plot_mode = 'lambert'
assert 'lambert' in str(type(self.viewer.axes)).lower()
viewer_state.plot_mode = 'mollweide'
assert 'mollweide' in str(type(self.viewer.axes)).lower()
def test_limit_log_set_polar(self):
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
viewer_state.plot_mode = "polar"
axes = self.viewer.axes
viewer_state.x_min = 0.5
viewer_state.x_max = 1.5
assert_allclose(axes.get_xlim(), [0.5, 1.5])
viewer_state.y_min = -2.5
viewer_state.y_max = 2.5
assert_allclose(axes.get_ylim(), [-2.5, 2.5])
viewer_state.y_log = True
assert axes.get_yscale() == 'log'
def test_limit_set_fullsphere(self):
# Make sure that the full-sphere projections ignore instead of throwing exceptions
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
for proj in fullsphere_projections:
viewer_state.plot_mode = proj
error_msg = 'Issue with {} projection'.format(proj)
axes = self.viewer.axes
viewer_state.x_min = 0.5
viewer_state.x_max = 1.5
viewer_state.y_min = -2.5
viewer_state.y_max = 2.5
assert_allclose(axes.get_xlim(), [-np.pi, np.pi], err_msg=error_msg)
assert_allclose(axes.get_ylim(), [-np.pi / 2, np.pi / 2], err_msg=error_msg)
def test_changing_mode_limits(self):
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
old_xmin = viewer_state.x_min
old_xmax = viewer_state.x_max
old_ymin = viewer_state.y_min
old_ymax = viewer_state.y_max
# Make sure limits are reset first
viewer_state.x_max += 3
viewer_state.plot_mode = 'polar'
assert_allclose(viewer_state.x_min, old_xmin)
assert_allclose(viewer_state.x_max, old_xmax)
assert_allclose(self.viewer.axes.get_xlim(), [old_xmin, old_xmax])
assert_allclose(viewer_state.y_min, old_ymin)
assert_allclose(viewer_state.y_max, old_ymax)
assert_allclose(self.viewer.axes.get_ylim(), [old_ymin, old_ymax])
viewer_state.plot_mode = 'rectilinear'
assert_allclose(viewer_state.x_min, old_xmin)
assert_allclose(viewer_state.x_max, old_xmax)
assert_allclose(self.viewer.axes.get_xlim(), [old_xmin, old_xmax])
assert_allclose(viewer_state.y_min, old_ymin)
assert_allclose(viewer_state.y_max, old_ymax)
assert_allclose(self.viewer.axes.get_ylim(), [old_ymin, old_ymax])
for proj in fullsphere_projections:
viewer_state.plot_mode = 'rectilinear'
viewer_state.plot_mode = proj
error_msg = 'Issue with {} projection'.format(proj)
assert_allclose(viewer_state.x_min, -np.pi)
assert_allclose(viewer_state.x_max, np.pi)
assert_allclose(self.viewer.axes.get_xlim(), [-np.pi, np.pi], err_msg=error_msg)
assert_allclose(viewer_state.y_min, -np.pi / 2)
assert_allclose(viewer_state.y_max, np.pi / 2)
assert_allclose(self.viewer.axes.get_ylim(), [-np.pi / 2, np.pi / 2], err_msg=error_msg)
def test_changing_mode_log(self):
# Test to make sure we reset the log axes to false when changing modes to prevent problems
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
viewer_state.x_log = True
viewer_state.y_log = True
viewer_state.plot_mode = 'polar'
assert not viewer_state.x_log
assert not viewer_state.y_log
assert self.viewer.axes.get_xscale() == 'linear'
assert self.viewer.axes.get_yscale() == 'linear'
viewer_state.y_log = True
viewer_state.plot_mode = 'rectilinear'
assert not viewer_state.x_log
assert not viewer_state.y_log
assert self.viewer.axes.get_xscale() == 'linear'
assert self.viewer.axes.get_yscale() == 'linear'
for proj in fullsphere_projections:
viewer_state.plot_mode = 'rectilinear'
viewer_state.x_log = True
viewer_state.y_log = True
viewer_state.plot_mode = proj
error_msg = 'Issue with {} projection'.format(proj)
assert not viewer_state.x_log, error_msg
assert not viewer_state.y_log, error_msg
assert self.viewer.axes.get_xscale() == 'linear', error_msg
assert self.viewer.axes.get_yscale() == 'linear', error_msg
def test_full_circle_utility(self):
# Make sure that the full circle function behaves well
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
old_xmin = viewer_state.x_min
old_xmax = viewer_state.x_max
old_ymin = viewer_state.y_min
old_ymax = viewer_state.y_max
viewer_state.full_circle()
assert_allclose([viewer_state.x_min, viewer_state.x_max], [old_xmin, old_xmax])
assert_allclose([viewer_state.y_min, viewer_state.y_max], [old_ymin, old_ymax])
viewer_state.plot_mode = 'polar'
viewer_state.full_circle()
assert_allclose([viewer_state.x_min, viewer_state.x_max], [0, 2 * np.pi])
assert_allclose([viewer_state.y_min, viewer_state.y_max], [old_ymin, old_ymax])
for proj in fullsphere_projections:
error_msg = 'Issue with {} projection'.format(proj)
viewer_state.plot_mode = proj
viewer_state.full_circle()
assert_allclose([viewer_state.x_min, viewer_state.x_max], [-np.pi, np.pi], err_msg=error_msg)
assert_allclose([viewer_state.y_min, viewer_state.y_max], [-np.pi / 2, np.pi / 2], err_msg=error_msg)
def test_limits_log_widget_polar_cartesian(self):
ui = self.viewer.options_widget().ui
viewer_state = self.viewer.state
viewer_state.plot_mode = 'polar'
assert not ui.bool_x_log.isEnabled()
assert not ui.bool_x_log_.isEnabled()
assert ui.bool_y_log.isEnabled()
assert ui.bool_y_log_.isEnabled()
assert ui.valuetext_x_min.isEnabled()
assert ui.button_flip_x.isEnabled()
assert ui.valuetext_x_max.isEnabled()
assert ui.valuetext_y_min.isEnabled()
assert ui.button_flip_y.isEnabled()
assert ui.valuetext_y_max.isEnabled()
assert not ui.button_full_circle.isHidden()
viewer_state.plot_mode = 'rectilinear'
assert ui.bool_x_log.isEnabled()
assert ui.bool_x_log_.isEnabled()
assert ui.bool_y_log.isEnabled()
assert ui.bool_y_log_.isEnabled()
assert ui.valuetext_x_min.isEnabled()
assert ui.button_flip_x.isEnabled()
assert ui.valuetext_x_max.isEnabled()
assert ui.valuetext_y_min.isEnabled()
assert ui.button_flip_y.isEnabled()
assert ui.valuetext_y_max.isEnabled()
assert ui.button_full_circle.isHidden()
assert ui.button_full_circle.isHidden()
def test_limits_log_widget_fullsphere(self):
ui = self.viewer.options_widget().ui
viewer_state = self.viewer.state
for proj in fullsphere_projections:
error_msg = 'Issue with {} projection'.format(proj)
viewer_state.plot_mode = proj
not ui.bool_x_log.isEnabled()
assert not ui.bool_x_log_.isEnabled(), error_msg
assert not ui.bool_y_log.isEnabled(), error_msg
assert not ui.bool_y_log_.isEnabled(), error_msg
assert not ui.valuetext_x_min.isEnabled(), error_msg
assert not ui.button_flip_x.isEnabled(), error_msg
assert not ui.valuetext_x_max.isEnabled(), error_msg
assert not ui.valuetext_y_min.isEnabled(), error_msg
assert not ui.button_flip_y.isEnabled(), error_msg
assert not ui.valuetext_y_max.isEnabled(), error_msg
assert ui.button_full_circle.isHidden(), error_msg
viewer_state.plot_mode = 'rectilinear'
assert ui.bool_x_log.isEnabled()
assert ui.bool_x_log_.isEnabled()
assert ui.bool_y_log.isEnabled()
assert ui.bool_y_log_.isEnabled()
assert ui.valuetext_x_min.isEnabled()
assert ui.button_flip_x.isEnabled()
assert ui.valuetext_x_max.isEnabled()
assert ui.valuetext_y_min.isEnabled()
assert ui.button_flip_y.isEnabled()
assert ui.valuetext_y_max.isEnabled()
assert ui.button_full_circle.isHidden()
def test_apply_roi_polar(self):
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
roi = RectangularROI(0, 0.5, 0, 0.5)
viewer_state.plot_mode = 'polar'
viewer_state.full_circle()
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert len(self.data.subsets) == 1
assert_allclose(self.data.subsets[0].to_mask(), [1, 0, 0, 0])
state = self.data.subsets[0].subset_state
assert isinstance(state, RoiSubsetState)
assert state.pretransform
pretrans = state.pretransform
assert isinstance(pretrans, ProjectionMplTransform)
assert pretrans._state['projection'] == 'polar'
assert_allclose(pretrans._state['x_lim'], [viewer_state.x_min, viewer_state.x_max])
assert_allclose(pretrans._state['y_lim'], [viewer_state.y_min, viewer_state.y_max])
assert pretrans._state['x_scale'] == 'linear'
assert pretrans._state['y_scale'] == 'linear'
self.data.subsets[0].delete()
viewer_state.y_log = True
self.viewer.apply_roi(roi)
state = self.data.subsets[0].subset_state
assert state.pretransform
pretrans = state.pretransform
assert isinstance(pretrans, ProjectionMplTransform)
assert pretrans._state['y_scale'] == 'log'
def test_apply_roi_fullsphere(self):
self.viewer.add_data(self.data)
viewer_state = self.viewer.state
roi = RectangularROI(0, 0.5, 0, 0.5)
for proj in fullsphere_projections:
viewer_state.plot_mode = proj
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert len(self.data.subsets) == 1
subset = self.data.subsets[0]
state = subset.subset_state
assert isinstance(state, RoiSubsetState)
assert state.pretransform
pretrans = state.pretransform
assert isinstance(pretrans, ProjectionMplTransform)
assert pretrans._state['projection'] == proj
assert_allclose(pretrans._state['x_lim'], [viewer_state.x_min, viewer_state.x_max])
assert_allclose(pretrans._state['y_lim'], [viewer_state.y_min, viewer_state.y_max])
assert pretrans._state['x_scale'] == 'linear'
assert pretrans._state['y_scale'] == 'linear'
subset.delete()
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/data_viewer.py 0000644 0001750 0001750 00000002734 13752534424 024000 0 ustar noahfx noahfx from glue.utils import defer_draw, decorate_all_methods
from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.scatter.qt.layer_style_editor import ScatterLayerStyleEditor
from glue.viewers.scatter.layer_artist import ScatterLayerArtist
from glue.viewers.scatter.qt.options_widget import ScatterOptionsWidget
from glue.viewers.scatter.state import ScatterViewerState
from glue.viewers.scatter.viewer import MatplotlibScatterMixin
__all__ = ['ScatterViewer']
@decorate_all_methods(defer_draw)
class ScatterViewer(MatplotlibScatterMixin, MatplotlibDataViewer):
LABEL = '2D Scatter'
_layer_style_widget_cls = ScatterLayerStyleEditor
_state_cls = ScatterViewerState
_options_cls = ScatterOptionsWidget
_data_artist_cls = ScatterLayerArtist
_subset_artist_cls = ScatterLayerArtist
tools = ['select:rectangle', 'select:xrange',
'select:yrange', 'select:circle',
'select:polygon']
def __init__(self, session, parent=None, state=None):
proj = None if not state or not state.plot_mode else state.plot_mode
MatplotlibDataViewer.__init__(self, session, parent=parent, state=state, projection=proj)
MatplotlibScatterMixin.setup_callbacks(self)
def limits_to_mpl(self, *args):
# These projections throw errors if we try to set the limits
if self.state.plot_mode in ['aitoff', 'hammer', 'lambert', 'mollweide']:
return
super().limits_to_mpl(*args)
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/options_widget.ui 0000644 0001750 0001750 00000025612 13752534424 024531 0 ustar noahfx noahfx
Widget
0
0
332
152
2D Scatter
5
5
5
5
5
-
QTabWidget::North
0
false
false
false
false
General
10
10
10
10
10
5
-
Qt::Vertical
20
40
-
75
true
x axis
-
75
true
y axis
-
QComboBox::AdjustToMinimumContentsLength
-
log
true
-
Qt::Horizontal
40
5
-
QComboBox::AdjustToMinimumContentsLength
-
log
true
-
-
75
true
type
Limits
10
10
10
10
10
5
-
75
true
x axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
Qt::Vertical
20
40
-
log
true
-
-
75
true
y axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
padding: 0px
⇄
-
padding: 0px
⇄
-
log
true
-
-
-
Qt::Horizontal
40
5
-
true
full circle
Axes
5
5
5
5
-
Legend
5
5
5
5
-
AxesEditorWidget
QWidget
glue.viewers.matplotlib.qt.axes_editor
LegendEditorWidget
QWidget
glue.viewers.matplotlib.qt.legend_editor
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/__init__.py 0000644 0001750 0001750 00000000205 13502206677 023233 0 ustar noahfx noahfx from .data_viewer import ScatterViewer # noqa
def setup():
from glue.config import qt_client
qt_client.add(ScatterViewer)
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/options_widget.py 0000644 0001750 0001750 00000007460 13752534424 024545 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
from glue.viewers.matplotlib.state import MatplotlibDataViewerState
__all__ = ['ScatterOptionsWidget']
def _get_labels(proj):
if proj == 'rectilinear':
return 'x axis', 'y axis'
elif proj == 'polar':
return 'theta (rad)', 'radius'
elif proj in ['aitoff', 'hammer', 'lambert', 'mollweide']:
return 'long (rad)', 'lat (rad)'
else:
return 'axis 1', 'axis 2'
class ScatterOptionsWidget(QtWidgets.QWidget):
def __init__(self, viewer_state, session, parent=None):
super(ScatterOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self._connections = autoconnect_callbacks_to_qt(viewer_state, self.ui)
self._connections_axes = autoconnect_callbacks_to_qt(viewer_state, self.ui.axes_editor.ui)
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections_legend = autoconnect_callbacks_to_qt(viewer_state.legend, self.ui.legend_editor.ui, connect_kwargs)
self.viewer_state = viewer_state
viewer_state.add_callback('x_att', self._update_x_attribute)
viewer_state.add_callback('y_att', self._update_y_attribute)
viewer_state.add_callback('plot_mode', self._update_plot_mode)
self.ui.button_full_circle.setVisible(False)
self.session = session
self.ui.axes_editor.button_apply_all.clicked.connect(self._apply_all_viewers)
def _apply_all_viewers(self):
for tab in self.session.application.viewers:
for viewer in tab:
if isinstance(viewer.state, MatplotlibDataViewerState):
viewer.state.update_axes_settings_from(self.viewer_state)
def _update_x_attribute(self, *args):
# If at least one of the components is categorical or a date, disable log button
log_enabled = ('categorical' not in self.viewer_state.x_kinds and self.viewer_state.plot_mode not in ['aitoff', 'hammer', 'lambert', 'mollweide', 'polar'])
self.ui.bool_x_log.setEnabled(log_enabled)
self.ui.bool_x_log_.setEnabled(log_enabled)
if not log_enabled:
self.ui.bool_x_log.setChecked(False)
self.ui.bool_x_log_.setChecked(False)
def _update_y_attribute(self, *args):
# If at least one of the components is categorical or a date, disable log button
log_enabled = ('categorical' not in self.viewer_state.y_kinds and self.viewer_state.plot_mode not in ['aitoff', 'hammer', 'lambert', 'mollweide'])
self.ui.bool_y_log.setEnabled(log_enabled)
self.ui.bool_y_log_.setEnabled(log_enabled)
if not log_enabled:
self.ui.bool_y_log.setChecked(False)
self.ui.bool_y_log_.setChecked(False)
def _update_plot_mode(self, *args):
x_label, y_label = _get_labels(self.viewer_state.plot_mode)
self.ui.x_lab.setText(x_label)
self.ui.x_lab_2.setText(x_label)
self.ui.y_lab.setText(y_label)
self.ui.y_lab_2.setText(y_label)
lim_enabled = self.viewer_state.plot_mode not in ['aitoff', 'hammer', 'lambert', 'mollweide']
is_polar = self.viewer_state.plot_mode == 'polar'
self.ui.valuetext_x_min.setEnabled(lim_enabled)
self.ui.button_flip_x.setEnabled(lim_enabled)
self.ui.valuetext_x_max.setEnabled(lim_enabled)
self.ui.valuetext_y_min.setEnabled(lim_enabled)
self.ui.button_flip_y.setEnabled(lim_enabled)
self.ui.valuetext_y_max.setEnabled(lim_enabled)
self.ui.button_full_circle.setVisible(is_polar)
self._update_x_attribute()
self._update_y_attribute()
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/layer_style_editor.ui 0000644 0001750 0001750 00000076125 13502206677 025401 0 ustar noahfx noahfx
Form
0
0
330
296
Form
5
5
5
5
-
0
Qt::ElideNone
Color
10
3
10
3
10
5
-
100
Qt::Horizontal
-
75
true
opacity
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
Qt::Horizontal
40
1
-
0
0
-
-
Qt::Vertical
20
40
-
QComboBox::AdjustToMinimumContentsLength
-
80
16777215
-
padding: 0px
⇄
-
75
true
color
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
limits
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
colormap
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
attribute
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
0
0
QComboBox::AdjustToMinimumContentsLength
Points
10
3
10
3
10
5
-
120
16777215
QComboBox::AdjustToMinimumContentsLength
-
75
true
show
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
Qt::LeftToRight
limits
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
padding: 0px
⇄
-
75
true
dpi
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
75
true
Qt::LeftToRight
attribute
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
Qt::LeftToRight
scaling
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
Qt::LeftToRight
size
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
40
1
-
-
Qt::Vertical
20
40
-
100
50
Qt::Horizontal
-
0
0
80
16777215
-
75
true
type
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
QComboBox::AdjustToMinimumContentsLength
-
-
75
true
stretch
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
-
16777215
16777215
QComboBox::AdjustToMinimumContentsLength
-
75
true
contrast
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
-
75
true
fill
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Line
10
3
10
3
10
5
-
Qt::Horizontal
40
1
-
1
-
75
true
width
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Vertical
20
40
-
-
75
true
style
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
show
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Errors
10
3
10
3
10
5
-
Qt::Vertical
20
40
-
Qt::Horizontal
40
1
-
QComboBox::AdjustToMinimumContentsLength
-
QComboBox::AdjustToMinimumContentsLength
-
-
-
75
true
show y
-
75
true
show x
-
color: #BB2200
Warning: adding errorbars may be slow
Qt::AlignCenter
Vectors
10
3
10
3
10
5
-
Show arrow
-
QComboBox::AdjustToMinimumContentsLength
-
75
true
show
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
QComboBox::AdjustToMinimumContentsLength
-
75
true
vx
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
0
0
16777215
16777215
-
75
true
arrow
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
75
true
type
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
75
true
vy
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
origin
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Qt::Horizontal
40
1
-
Qt::Vertical
20
40
-
Qt::Horizontal
-
75
true
scaling
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
color: #BB2200
Warning: adding vectors may be slow
Qt::AlignCenter
false
QColorBox
QLabel
QColormapCombo
QComboBox
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/qt/layer_style_editor.py 0000644 0001750 0001750 00000024161 13752534424 025406 0 ustar noahfx noahfx import os
import numpy as np
from qtpy import QtWidgets, QtGui
from qtpy.QtCore import Qt
from glue.core import BaseData
from echo.qt import autoconnect_callbacks_to_qt, connect_value
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
from glue.core.exceptions import IncompatibleAttribute
class ScatterLayerStyleEditor(QtWidgets.QWidget):
def __init__(self, layer, parent=None):
super(ScatterLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1)),
'size_scaling': dict(value_range=(0.1, 10), log=True),
'density_contrast': dict(value_range=(0, 1)),
'vector_scaling': dict(value_range=(0.1, 10), log=True)}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
self._connection_dpi = connect_value(layer.state.viewer_state, 'dpi', self.ui.value_dpi,
value_range=(12, 144), log=True)
fix_tab_widget_fontsize(self.ui.tab_widget)
self.layer_state = layer.state
self.layer_state.add_callback('markers_visible', self._update_markers_visible)
self.layer_state.add_callback('line_visible', self._update_line_visible)
self.layer_state.add_callback('xerr_visible', self._update_xerr_visible)
self.layer_state.add_callback('yerr_visible', self._update_yerr_visible)
self.layer_state.add_callback('vector_visible', self._update_vectors_visible)
self.layer_state.add_callback('cmap_mode', self._update_cmap_mode)
self.layer_state.add_callback('size_mode', self._update_size_mode)
self.layer_state.add_callback('vector_mode', self._update_vector_mode)
self.layer_state.add_callback('density_map', self._update_size_mode)
self.layer_state.add_callback('density_map', self._update_warnings)
self.layer_state.add_callback('density_map', self._update_checkboxes)
self.layer_state.viewer_state.add_callback('x_att', self._update_checkboxes)
self.layer_state.viewer_state.add_callback('y_att', self._update_checkboxes)
if hasattr(self.layer_state.viewer_state, 'plot_mode'):
self.layer_state.viewer_state.add_callback('plot_mode', self._update_vectors_visible)
self.layer_state.add_callback('layer', self._update_warnings)
self._update_markers_visible()
self._update_line_visible()
self._update_xerr_visible()
self._update_yerr_visible()
self._update_vectors_visible()
self._update_size_mode()
self._update_vector_mode()
self._update_cmap_mode()
self._update_checkboxes()
self._update_warnings()
def _update_warnings(self, *args):
if self.layer_state.layer is None:
n_points = 0
else:
n_points = np.product(self.layer_state.layer.shape)
warning = " (may be slow given data size)"
for combo, threshold in [(self.ui.combosel_size_mode, 10000),
(self.ui.combosel_cmap_mode, 50000)]:
if n_points > threshold and not self.layer_state.density_map:
for item in range(combo.count()):
text = combo.itemText(item)
if text != 'Fixed':
combo.setItemText(item, text + warning)
combo.setItemData(item, QtGui.QBrush(Qt.red), Qt.TextColorRole)
else:
for item in range(combo.count()):
text = combo.itemText(item)
if text != 'Fixed':
if warning in text:
combo.setItemText(item, text.replace(warning, ''))
combo.setItemData(item, QtGui.QBrush(), Qt.TextColorRole)
if n_points > 10000:
self.ui.label_warning_errorbar.show()
else:
self.ui.label_warning_errorbar.hide()
if n_points > 10000:
self.ui.label_warning_vector.show()
else:
self.ui.label_warning_vector.hide()
def _update_size_mode(self, size_mode=None):
visible = not self.layer_state.density_map and not self.layer_state.size_mode == 'Fixed'
self.ui.label_size_attribute.setVisible(visible)
self.ui.combosel_size_att.setVisible(visible)
self.ui.label_size_limits.setVisible(visible)
self.ui.valuetext_size_vmin.setVisible(visible)
self.ui.valuetext_size_vmax.setVisible(visible)
self.ui.button_flip_size.setVisible(visible)
visible = not self.layer_state.density_map and self.layer_state.size_mode == 'Fixed'
self.ui.value_size.setVisible(visible)
density = self.layer_state.density_map
self.ui.value_dpi.setVisible(density)
self.ui.label_dpi.setVisible(density)
self.ui.label_stretch.setVisible(density)
self.ui.combosel_stretch.setVisible(density)
self.ui.value_density_contrast.setVisible(density)
self.ui.label_contrast.setVisible(density)
self.ui.combosel_size_mode.setVisible(not density)
self.ui.value_size_scaling.setVisible(not density)
self.ui.label_size_mode.setVisible(not density)
self.ui.label_size_scaling.setVisible(not density)
self.ui.label_fill.setVisible(not density)
self.ui.bool_fill.setVisible(not density)
def _update_markers_visible(self, *args):
self.ui.combosel_size_mode.setEnabled(self.layer_state.markers_visible)
self.ui.value_size.setEnabled(self.layer_state.markers_visible)
self.ui.combosel_size_att.setEnabled(self.layer_state.markers_visible)
self.ui.valuetext_size_vmin.setEnabled(self.layer_state.markers_visible)
self.ui.valuetext_size_vmax.setEnabled(self.layer_state.markers_visible)
self.ui.button_flip_size.setEnabled(self.layer_state.markers_visible)
self.ui.value_size_scaling.setEnabled(self.layer_state.markers_visible)
self.ui.value_dpi.setEnabled(self.layer_state.markers_visible)
self.ui.combosel_stretch.setEnabled(self.layer_state.markers_visible)
self.ui.label_size_scaling.setEnabled(self.layer_state.markers_visible)
self.ui.combosel_points_mode.setEnabled(self.layer_state.markers_visible)
self.ui.value_density_contrast.setEnabled(self.layer_state.markers_visible)
def _update_checkboxes(self, *args):
if isinstance(self.layer_state.layer, BaseData):
layer = self.layer_state.layer
else:
layer = self.layer_state.layer.data
try:
x_datetime = layer.get_kind(self.layer_state.viewer_state.x_att) == 'datetime'
except IncompatibleAttribute:
x_datetime = False
try:
y_datetime = layer.get_kind(self.layer_state.viewer_state.y_att) == 'datetime'
except IncompatibleAttribute:
y_datetime = False
for checkbox in [self.ui.bool_line_visible, self.ui.bool_xerr_visible,
self.ui.bool_yerr_visible, self.ui.bool_vector_visible]:
if self.layer_state.density_map:
checkbox.setEnabled(False)
checkbox.setToolTip('Not available with density map')
else:
if ((x_datetime and checkbox in (self.ui.bool_xerr_visible, self.ui.bool_vector_visible)) or
(y_datetime and checkbox in (self.ui.bool_yerr_visible, self.ui.bool_vector_visible))):
checkbox.setEnabled(False)
checkbox.setToolTip('Not available when using datetime attribute')
else:
checkbox.setEnabled(True)
checkbox.setToolTip('')
def _update_line_visible(self, *args):
self.ui.value_linewidth.setEnabled(self.layer_state.line_visible)
self.ui.combosel_linestyle.setEnabled(self.layer_state.line_visible)
def _update_xerr_visible(self, *args):
self.ui.combosel_xerr_att.setEnabled(self.layer_state.xerr_visible)
def _update_yerr_visible(self, *args):
self.ui.combosel_yerr_att.setEnabled(self.layer_state.yerr_visible)
def _update_vectors_visible(self, *args):
viewer_state = self.layer_state.viewer_state
is_rect = not hasattr(viewer_state, 'plot_mode') or viewer_state.plot_mode == 'rectilinear'
self.ui.combosel_vector_mode.setEnabled(self.layer_state.vector_visible and is_rect)
self.ui.combosel_vx_att.setEnabled(self.layer_state.vector_visible)
self.ui.combosel_vy_att.setEnabled(self.layer_state.vector_visible)
self.ui.value_vector_scaling.setEnabled(self.layer_state.vector_visible)
self.ui.combosel_vector_origin.setEnabled(self.layer_state.vector_visible)
self.ui.bool_vector_arrowhead.setEnabled(self.layer_state.vector_visible)
def _update_vector_mode(self, vector_mode=None):
if self.layer_state.vector_mode == 'Cartesian':
self.ui.label_vector_x.setText('vx')
self.ui.label_vector_y.setText('vy')
elif self.layer_state.vector_mode == 'Polar':
self.ui.label_vector_x.setText('angle (deg)')
self.ui.label_vector_y.setText('length')
def _update_cmap_mode(self, cmap_mode=None):
if self.layer_state.cmap_mode == 'Fixed':
self.ui.label_cmap_attribute.hide()
self.ui.combosel_cmap_att.hide()
self.ui.label_cmap_limits.hide()
self.ui.valuetext_cmap_vmin.hide()
self.ui.valuetext_cmap_vmax.hide()
self.ui.button_flip_cmap.hide()
self.ui.combodata_cmap.hide()
self.ui.label_colormap.hide()
self.ui.color_color.show()
else:
self.ui.label_cmap_attribute.show()
self.ui.combosel_cmap_att.show()
self.ui.label_cmap_limits.show()
self.ui.valuetext_cmap_vmin.show()
self.ui.valuetext_cmap_vmax.show()
self.ui.button_flip_cmap.show()
self.ui.combodata_cmap.show()
self.ui.label_colormap.show()
self.ui.color_color.hide()
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/python_export.py 0000644 0001750 0001750 00000021516 13752534424 024003 0 ustar noahfx noahfx from glue.viewers.common.python_export import code, serialize_options
def python_export_scatter_layer(layer, *args):
if len(layer.mpl_artists) == 0 or not layer.enabled or not layer.visible:
return [], None
script = ""
imports = ["import numpy as np"]
script += "layer_handles = [] # for legend"
script += "# Get main data values\n"
script += "x = layer_data['{0}']\n".format(layer._viewer_state.x_att.label)
script += "y = layer_data['{0}']\n".format(layer._viewer_state.y_att.label)
script += "keep = ~np.isnan(x) & ~np.isnan(y)\n\n"
if layer.state.cmap_mode == 'Linear':
script += "# Set up colors\n"
script += "colors = layer_data['{0}']\n".format(layer.state.cmap_att.label)
script += "cmap_vmin = {0}\n".format(layer.state.cmap_vmin)
script += "cmap_vmax = {0}\n".format(layer.state.cmap_vmax)
script += "keep &= ~np.isnan(colors)\n"
script += "colors = plt.cm.{0}((colors - cmap_vmin) / (cmap_vmax - cmap_vmin))\n\n".format(layer.state.cmap.name)
if layer.state.size_mode == 'Linear':
imports = ['import numpy as np']
script += "# Set up size values\n"
script += "sizes = layer_data['{0}']\n".format(layer.state.size_att.label)
script += "size_vmin = {0}\n".format(layer.state.size_vmin)
script += "size_vmax = {0}\n".format(layer.state.size_vmax)
script += "keep &= ~np.isnan(sizes)\n"
script += "sizes = 30 * (np.clip((sizes - size_vmin) / (size_vmax - size_vmin), 0, 1) * 0.95 + 0.05) * {0}\n\n".format(layer.state.size_scaling)
if layer.state.markers_visible:
if layer.state.density_map:
imports += ["from mpl_scatter_density import ScatterDensityArtist"]
imports += ["from glue.viewers.scatter.layer_artist import DensityMapLimits, STRETCHES"]
imports += ["from astropy.visualization import ImageNormalize"]
script += "density_limits = DensityMapLimits()\n"
script += "density_limits.contrast = {0}\n\n".format(layer.state.density_contrast)
options = dict(alpha=layer.state.alpha,
zorder=layer.state.zorder,
dpi=layer._viewer_state.dpi)
if layer.state.cmap_mode == 'Fixed':
options['color'] = layer.state.color
options['vmin'] = code('density_limits.min')
options['vmax'] = code('density_limits.max')
options['norm'] = code("ImageNormalize(stretch=STRETCHES['{0}']())".format(layer.state.stretch))
else:
options['c'] = code("layer_data['{0}']".format(layer.state.cmap_att.label))
options['cmap'] = code("plt.cm.{0}".format(layer.state.cmap.name))
options['vmin'] = layer.state.cmap_vmin
options['vmax'] = layer.state.cmap_vmax
script += "density = ScatterDensityArtist(ax, x, y, {0})\n".format(serialize_options(options))
script += "ax.add_artist(density)\n\n"
# legend
imports += ["from matplotlib.lines import Line2D"]
options = dict(ms=layer.state.size,
alpha=layer.state.alpha,
color=layer.state.color)
script += "layer_handles.append(\n"
script += " Line2D([0, ], [0, ],\n"
script += " marker='.', linestyle='none',\n"
script += " {0}))\n".format(serialize_options(options))
else:
if layer._use_plot_artist():
options = dict(color=layer.state.color,
markersize=layer.state.size * layer.state.size_scaling,
alpha=layer.state.alpha,
zorder=layer.state.zorder,
label=layer.layer.label)
if layer.state.fill:
options['mec'] = 'none'
else:
options['mfc'] = 'none'
script += "plot_artists = ax.plot(x[keep], y[keep], 'o', {0})\n".format(serialize_options(options))
script += "layer_handles.extend(plot_artists)\n\n"
else:
options = dict(alpha=layer.state.alpha,
zorder=layer.state.zorder)
if layer.state.cmap_mode == 'Fixed':
options['facecolor'] = layer.state.color
else:
options['c'] = code('colors[keep]')
if layer.state.size_mode == 'Fixed':
options['s'] = code('{0} ** 2'.format(layer.state.size * layer.state.size_scaling))
else:
options['s'] = code('sizes[keep] ** 2')
if layer.state.fill:
options['edgecolor'] = 'none'
script += "scatter_artist = ax.scatter(x[keep], y[keep], {0})\n".format(serialize_options(options))
if not layer.state.fill:
script += "scatter_artist.set_edgecolors(scatter_artist.get_facecolors())\n"
script += "scatter_artist.set_facecolors('none')\n"
script += "layer_handles.append(scatter_artist)\n\n"
if layer.state.vector_visible:
if layer.state.vx_att is not None and layer.state.vy_att is not None:
imports += ['import numpy as np']
script += "# Get vector data\n"
if layer.state.vector_mode == 'Polar':
script += "angle = layer_data['{0}'][keep]\n".format(layer.state.vx_att.label)
script += "length = layer_data['{0}'][keep]\n".format(layer.state.vy_att.label)
script += "vx = length * np.cos(np.radians(angle))\n"
script += "vy = length * np.sin(np.radians(angle))\n"
else:
script += "vx = layer_data['{0}'][keep]\n".format(layer.state.vx_att.label)
script += "vy = layer_data['{0}'][keep]\n".format(layer.state.vy_att.label)
if layer.state.vector_arrowhead:
hw = 3
hl = 5
else:
hw = 1
hl = 0
script += 'vmax = np.nanmax(np.hypot(vx, vy))\n\n'
scale = code('{0} * vmax'.format(10 / layer.state.vector_scaling))
options = dict(units='width',
pivot=layer.state.vector_origin,
headwidth=hw, headlength=hl,
scale_units='width',
scale=scale,
angles='xy',
alpha=layer.state.alpha,
zorder=layer.state.zorder)
if layer.state.cmap_mode == 'Fixed':
options['color'] = layer.state.color
else:
options['color'] = code('colors[keep]')
script += "vector_artist = ax.quiver(x[keep], y[keep], vx, vy, {0})\n".format(serialize_options(options))
script += "layer_handles.append(vector_artist)\n\n"
if layer.state.xerr_visible or layer.state.yerr_visible:
if layer.state.xerr_visible and layer.state.xerr_att is not None:
xerr = code("xerr[keep]")
else:
xerr = code("None")
if layer.state.yerr_visible and layer.state.yerr_att is not None:
yerr = code("yerr[keep]")
else:
yerr = code("None")
options = dict(fmt='none', xerr=xerr, yerr=yerr,
alpha=layer.state.alpha, zorder=layer.state.zorder)
if layer.state.cmap_mode == 'Fixed':
options['ecolor'] = layer.state.color
else:
options['ecolor'] = code('colors[keep]')
script += "xerr = layer_data['{0}']\n".format(layer.state.xerr_att.label)
script += "yerr = layer_data['{0}']\n".format(layer.state.yerr_att.label)
script += "keep &= ~np.isnan(xerr) & ~np.isnan(yerr)\n"
script += "error_artist = ax.errorbar(x[keep], y[keep], {0})\n".format(serialize_options(options))
script += "layer_handles.append(error_artist)\n\n"
if layer.state.line_visible:
options = dict(color=layer.state.color,
linewidth=layer.state.linewidth,
linestyle=layer.state.linestyle,
alpha=layer.state.alpha,
zorder=layer.state.zorder)
if layer.state.cmap_mode == 'Fixed':
script += "ax.plot(x[keep], y[keep], '-', {0})\n\n".format(serialize_options(options))
else:
options['c'] = code('colors')
imports.append("from glue.viewers.scatter.layer_artist import plot_colored_line")
script += "line_collection = plot_colored_line(ax, x, y, {0})\n".format(serialize_options(options))
script += "layer_handles.append(line_collection)\n\n"
script += "legend_handles.append(tuple(layer_handles))\n"
script += "legend_labels.append(layer_data.label)\n\n"
return imports, script.strip()
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/state.py 0000644 0001750 0001750 00000043365 13752534424 022207 0 ustar noahfx noahfx # -*- coding: utf-8 -*-
import numpy as np
from glue.core import BaseData, Subset
from glue.config import colormaps
from glue.viewers.matplotlib.state import (MatplotlibDataViewerState,
MatplotlibLayerState,
DeferredDrawCallbackProperty as DDCProperty,
DeferredDrawSelectionCallbackProperty as DDSCProperty)
from glue.core.state_objects import StateAttributeLimitsHelper
from echo import keep_in_sync, delay_callback
from glue.core.data_combo_helper import ComponentIDComboHelper, ComboHelper
from glue.core.exceptions import IncompatibleAttribute
from matplotlib.projections import get_projection_names
__all__ = ['ScatterViewerState', 'ScatterLayerState']
class ScatterViewerState(MatplotlibDataViewerState):
"""
A state class that includes all the attributes for a scatter viewer.
"""
x_att = DDSCProperty(docstring='The attribute to show on the x-axis', default_index=0)
y_att = DDSCProperty(docstring='The attribute to show on the y-axis', default_index=1)
dpi = DDCProperty(72, docstring='The resolution (in dots per inch) of density maps, if present')
plot_mode = DDSCProperty(docstring="Whether to plot the data in cartesian, polar or another projection")
def __init__(self, **kwargs):
super(ScatterViewerState, self).__init__()
self.limits_cache = {}
self.x_lim_helper = StateAttributeLimitsHelper(self, attribute='x_att',
lower='x_min', upper='x_max',
log='x_log', margin=0.04,
limits_cache=self.limits_cache)
self.y_lim_helper = StateAttributeLimitsHelper(self, attribute='y_att',
lower='y_min', upper='y_max',
log='y_log', margin=0.04,
limits_cache=self.limits_cache)
self.add_callback('layers', self._layers_changed)
self.x_att_helper = ComponentIDComboHelper(self, 'x_att', pixel_coord=True, world_coord=True)
self.y_att_helper = ComponentIDComboHelper(self, 'y_att', pixel_coord=True, world_coord=True)
self.plot_mode_helper = ComboHelper(self, 'plot_mode')
self.plot_mode_helper.choices = [proj for proj in get_projection_names() if proj not in ['3d', 'scatter_density']]
self.plot_mode_helper.selection = 'rectilinear'
self.update_from_dict(kwargs)
self.add_callback('x_log', self._reset_x_limits)
self.add_callback('y_log', self._reset_y_limits)
def _reset_x_limits(self, *args):
if self.x_att is None:
return
self.x_lim_helper.percentile = 100
self.x_lim_helper.update_values(force=True)
def _reset_y_limits(self, *args):
if self.y_att is None:
return
self.y_lim_helper.percentile = 100
self.y_lim_helper.update_values(force=True)
def reset_limits(self):
self._reset_x_limits()
self._reset_y_limits()
def flip_x(self):
"""
Flip the x_min/x_max limits.
"""
self.x_lim_helper.flip_limits()
def flip_y(self):
"""
Flip the y_min/y_max limits.
"""
self.y_lim_helper.flip_limits()
def full_circle(self):
if not self.plot_mode == 'polar':
return
self.x_min = 0
self.x_max = 2 * np.pi
@property
def x_categories(self):
return self._categories(self.x_att)
@property
def y_categories(self):
return self._categories(self.y_att)
def _categories(self, cid):
categories = []
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer = layer_state.layer
else:
layer = layer_state.layer.data
try:
if layer.data.get_kind(cid) == 'categorical':
categories.append(layer.data.get_data(cid).categories)
except IncompatibleAttribute:
pass
if len(categories) == 0:
return None
else:
return np.unique(np.hstack(categories))
@property
def x_kinds(self):
return self._component_kinds(self.x_att)
@property
def y_kinds(self):
return self._component_kinds(self.y_att)
def _component_kinds(self, cid):
# Construct list of component kinds over all layers
kinds = set()
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer = layer_state.layer
else:
layer = layer_state.layer.data
try:
kinds.add(layer.data.get_kind(cid))
except IncompatibleAttribute:
pass
return kinds
def _layers_changed(self, *args):
layers_data = self.layers_data
layers_data_cache = getattr(self, '_layers_data_cache', [])
if layers_data == layers_data_cache:
return
self.x_att_helper.set_multiple_data(self.layers_data)
self.y_att_helper.set_multiple_data(self.layers_data)
self._layers_data_cache = layers_data
def display_func_slow(x):
if x == 'Linear':
return 'Linear (WARNING: may be slow due to data size)'
else:
return x
class ScatterLayerState(MatplotlibLayerState):
"""
A state class that includes all the attributes for layers in a scatter plot.
"""
# Color
cmap_mode = DDSCProperty(docstring="Whether to use color to encode an attribute")
cmap_att = DDSCProperty(docstring="The attribute to use for the color")
cmap_vmin = DDCProperty(docstring="The lower level for the colormap")
cmap_vmax = DDCProperty(docstring="The upper level for the colormap")
cmap = DDCProperty(docstring="The colormap to use (when in colormap mode)")
# Points
points_mode = DDSCProperty(docstring='Whether to use markers or a density map')
# Markers
markers_visible = DDCProperty(True, docstring="Whether to show markers")
size = DDCProperty(docstring="The size of the markers")
size_mode = DDSCProperty(docstring="Whether to use size to encode an attribute")
size_att = DDSCProperty(docstring="The attribute to use for the size")
size_vmin = DDCProperty(docstring="The lower level for the size mapping")
size_vmax = DDCProperty(docstring="The upper level for the size mapping")
size_scaling = DDCProperty(1, docstring="Relative scaling of the size")
fill = DDCProperty(True, docstring="Whether to fill the markers")
# Density map
density_map = DDCProperty(False, docstring="Whether to show the points as a density map")
stretch = DDSCProperty(default='log', docstring='The stretch used to render the layer, '
'which should be one of ``linear``, '
'``sqrt``, ``log``, or ``arcsinh``')
density_contrast = DDCProperty(1, docstring="The dynamic range of the density map")
# Note that we keep the dpi in the viewer state since we want it to always
# be in sync between layers.
# Line
line_visible = DDCProperty(False, docstring="Whether to show a line connecting all positions")
linewidth = DDCProperty(1, docstring="The line width")
linestyle = DDSCProperty(docstring="The line style")
# Errorbars
xerr_visible = DDCProperty(False, docstring="Whether to show x error bars")
yerr_visible = DDCProperty(False, docstring="Whether to show y error bars")
xerr_att = DDSCProperty(docstring="The attribute to use for the x error bars")
yerr_att = DDSCProperty(docstring="The attribute to use for the y error bars")
# Vectors
vector_visible = DDCProperty(False, docstring="Whether to show vector plot")
vx_att = DDSCProperty(docstring="The attribute to use for the x vector arrow")
vy_att = DDSCProperty(docstring="The attribute to use for the y vector arrow")
vector_arrowhead = DDCProperty(False, docstring="Whether to show vector arrow")
vector_mode = DDSCProperty(default_index=0, docstring="Whether to plot the vectors in cartesian or polar mode")
vector_origin = DDSCProperty(default_index=1, docstring="Whether to place the vector so that the origin is at the tail, middle, or tip")
vector_scaling = DDCProperty(1, docstring="The relative scaling of the arrow length")
def __init__(self, viewer_state=None, layer=None, **kwargs):
super(ScatterLayerState, self).__init__(viewer_state=viewer_state, layer=layer)
self.limits_cache = {}
self.cmap_lim_helper = StateAttributeLimitsHelper(self, attribute='cmap_att',
lower='cmap_vmin', upper='cmap_vmax',
limits_cache=self.limits_cache)
self.size_lim_helper = StateAttributeLimitsHelper(self, attribute='size_att',
lower='size_vmin', upper='size_vmax',
limits_cache=self.limits_cache)
self.cmap_att_helper = ComponentIDComboHelper(self, 'cmap_att',
numeric=True, datetime=False, categorical=False)
self.size_att_helper = ComponentIDComboHelper(self, 'size_att',
numeric=True, datetime=False, categorical=False)
self.xerr_att_helper = ComponentIDComboHelper(self, 'xerr_att',
numeric=True, datetime=False, categorical=False)
self.yerr_att_helper = ComponentIDComboHelper(self, 'yerr_att',
numeric=True, datetime=False, categorical=False)
self.vx_att_helper = ComponentIDComboHelper(self, 'vx_att',
numeric=True, datetime=False, categorical=False)
self.vy_att_helper = ComponentIDComboHelper(self, 'vy_att',
numeric=True, datetime=False, categorical=False)
points_mode_display = {'auto': 'Density map or markers (auto)',
'markers': 'Markers',
'density': 'Density map'}
ScatterLayerState.points_mode.set_choices(self, ['auto', 'markers', 'density'])
ScatterLayerState.points_mode.set_display_func(self, points_mode_display.get)
self.add_callback('points_mode', self._update_density_map_mode)
self.add_callback('density_map', self._on_density_map_change, priority=10000)
ScatterLayerState.cmap_mode.set_choices(self, ['Fixed', 'Linear'])
ScatterLayerState.size_mode.set_choices(self, ['Fixed', 'Linear'])
linestyle_display = {'solid': '–––––––',
'dashed': '– – – – –',
'dotted': '· · · · · · · ·',
'dashdot': '– · – · – ·'}
ScatterLayerState.linestyle.set_choices(self, ['solid', 'dashed', 'dotted', 'dashdot'])
ScatterLayerState.linestyle.set_display_func(self, linestyle_display.get)
ScatterLayerState.vector_mode.set_choices(self, ['Cartesian', 'Polar'])
vector_origin_display = {'tail': 'Tail of vector',
'middle': 'Middle of vector',
'tip': 'Tip of vector'}
ScatterLayerState.vector_origin.set_choices(self, ['tail', 'middle', 'tip'])
ScatterLayerState.vector_origin.set_display_func(self, vector_origin_display.get)
stretch_display = {'linear': 'Linear',
'sqrt': 'Square Root',
'arcsinh': 'Arcsinh',
'log': 'Logarithmic'}
ScatterLayerState.stretch.set_choices(self, ['linear', 'sqrt', 'arcsinh', 'log'])
ScatterLayerState.stretch.set_display_func(self, stretch_display.get)
if self.viewer_state is not None:
self.viewer_state.add_callback('x_att', self._on_xy_change, priority=10000)
self.viewer_state.add_callback('y_att', self._on_xy_change, priority=10000)
self._on_xy_change()
self.add_callback('layer', self._on_layer_change)
if layer is not None:
self._on_layer_change()
self.cmap = colormaps.members[0][1]
self.size = self.layer.style.markersize
self._sync_size = keep_in_sync(self, 'size', self.layer.style, 'markersize')
self.update_from_dict(kwargs)
def _on_xy_change(self, *event):
if self.viewer_state.x_att is None or self.viewer_state.y_att is None:
return
if isinstance(self.layer, BaseData):
layer = self.layer
else:
layer = self.layer.data
try:
x_datetime = layer.get_kind(self.viewer_state.x_att) == 'datetime'
except IncompatibleAttribute:
x_datetime = False
try:
y_datetime = layer.get_kind(self.viewer_state.y_att) == 'datetime'
except IncompatibleAttribute:
y_datetime = False
with delay_callback(self, 'xerr_visible', 'yerr_visible', 'vector_visible'):
if x_datetime:
self.xerr_visible = False
if y_datetime:
self.yerr_visible = False
if x_datetime or y_datetime:
self.vector_visible = False
def _on_layer_change(self, layer=None):
with delay_callback(self, 'cmap_vmin', 'cmap_vmax', 'size_vmin', 'size_vmax', 'density_map'):
self._update_density_map_mode()
if self.layer is None:
self.cmap_att_helper.set_multiple_data([])
self.size_att_helper.set_multiple_data([])
else:
self.cmap_att_helper.set_multiple_data([self.layer])
self.size_att_helper.set_multiple_data([self.layer])
if self.layer is None:
self.xerr_att_helper.set_multiple_data([])
self.yerr_att_helper.set_multiple_data([])
else:
self.xerr_att_helper.set_multiple_data([self.layer])
self.yerr_att_helper.set_multiple_data([self.layer])
if self.layer is None:
self.vx_att_helper.set_multiple_data([])
self.vy_att_helper.set_multiple_data([])
else:
self.vx_att_helper.set_multiple_data([self.layer])
self.vy_att_helper.set_multiple_data([self.layer])
def _update_density_map_mode(self, *args):
if self.points_mode == 'auto':
if self.layer.size > 100000:
self.density_map = True
else:
self.density_map = False
elif self.points_mode == 'density':
self.density_map = True
else:
self.density_map = False
def _on_density_map_change(self, *args):
# If the density map mode is used, we should disable the lines/errors/vectors
if self.density_map:
with delay_callback(self,
'line_visible', 'xerr_visible',
'yerr_visible', 'vector_visible'):
if self.line_visible:
self.line_visible = False
if self.xerr_visible:
self.xerr_visible = False
if self.yerr_visible:
self.yerr_visible = False
if self.vector_visible:
self.vector_visible = False
def flip_cmap(self):
"""
Flip the cmap_vmin/cmap_vmax limits.
"""
self.cmap_lim_helper.flip_limits()
def flip_size(self):
"""
Flip the size_vmin/size_vmax limits.
"""
self.size_lim_helper.flip_limits()
@property
def cmap_name(self):
return colormaps.name_from_cmap(self.cmap)
def compute_density_map(self, bins=None, range=None):
if not self.markers_visible or not self.density_map:
return np.zeros(bins)
if isinstance(self.layer, Subset):
data = self.layer.data
subset_state = self.layer.subset_state
else:
data = self.layer
subset_state = None
count = data.compute_histogram([self.viewer_state.y_att, self.viewer_state.x_att],
subset_state=subset_state, bins=bins,
log=(self.viewer_state.y_log, self.viewer_state.x_log),
range=range)
if self.cmap_mode == 'Fixed':
return count
else:
total = data.compute_histogram([self.viewer_state.y_att, self.viewer_state.x_att],
subset_state=subset_state, bins=bins,
weights=self.cmap_att,
log=(self.viewer_state.y_log, self.viewer_state.x_log),
range=range)
return total / count
@classmethod
def __setgluestate__(cls, rec, context):
# Patch for glue files produced with glue v0.11
if 'style' in rec['values']:
style = context.object(rec['values'].pop('style'))
if style == 'Scatter':
rec['values']['markers_visible'] = True
rec['values']['line_visible'] = False
elif style == 'Line':
rec['values']['markers_visible'] = False
rec['values']['line_visible'] = True
return super(ScatterLayerState, cls).__setgluestate__(rec, context)
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/__init__.py 0000644 0001750 0001750 00000000000 13502206677 022600 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/compat.py 0000644 0001750 0001750 00000004016 13605357235 022340 0 ustar noahfx noahfx import uuid
from .state import ScatterLayerState
STATE_CLASS = {}
STATE_CLASS['ScatterLayerArtist'] = ScatterLayerState
def update_scatter_viewer_state(rec, context):
"""
Given viewer session information, make sure the session information is
compatible with the current version of the viewers, and if not, update
the session information in-place.
"""
if '_protocol' not in rec:
# Note that files saved with protocol < 1 have bin settings saved per
# layer but they were always restricted to be the same, so we can just
# use the settings from the first layer
rec['state'] = {}
rec['state']['values'] = {}
# TODO: could generalize this into a mapping
properties = rec.pop('properties')
viewer_state = rec['state']['values']
viewer_state['x_min'] = properties['xmin']
viewer_state['x_max'] = properties['xmax']
viewer_state['y_min'] = properties['ymin']
viewer_state['y_max'] = properties['ymax']
viewer_state['x_log'] = properties['xlog']
viewer_state['y_log'] = properties['ylog']
viewer_state['x_att'] = properties['xatt']
viewer_state['y_att'] = properties['yatt']
layer_states = []
for layer in rec['layers']:
state_id = str(uuid.uuid4())
state_cls = STATE_CLASS[layer['_type'].split('.')[-1]]
state = state_cls(layer=context.object(layer.pop('layer')))
for prop in ('visible', 'zorder'):
value = layer.pop(prop)
value = context.object(value)
setattr(state, prop, value)
context.register_object(state_id, state)
layer['state'] = state_id
layer_states.append(state)
layer.pop('lo', None)
layer.pop('hi', None)
layer.pop('nbins', None)
layer.pop('xlog', None)
list_id = str(uuid.uuid4())
context.register_object(list_id, layer_states)
rec['state']['values']['layers'] = list_id
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/layer_artist.py 0000644 0001750 0001750 00000057335 13752534424 023573 0 ustar noahfx noahfx import warnings
import numpy as np
from matplotlib.colors import Normalize
from matplotlib.collections import LineCollection
from mpl_scatter_density.generic_density_artist import GenericDensityArtist
from astropy.visualization import (ImageNormalize, LinearStretch, SqrtStretch,
AsinhStretch, LogStretch)
from glue.utils import defer_draw, broadcast_to, nanmax, ensure_numerical, datetime64_to_mpl
from glue.viewers.scatter.state import ScatterLayerState
from glue.viewers.scatter.python_export import python_export_scatter_layer
from glue.viewers.matplotlib.layer_artist import MatplotlibLayerArtist
from glue.core.exceptions import IncompatibleAttribute
from matplotlib.lines import Line2D
STRETCHES = {'linear': LinearStretch,
'sqrt': SqrtStretch,
'arcsinh': AsinhStretch,
'log': LogStretch}
CMAP_PROPERTIES = set(['cmap_mode', 'cmap_att', 'cmap_vmin', 'cmap_vmax', 'cmap'])
MARKER_PROPERTIES = set(['size_mode', 'size_att', 'size_vmin', 'size_vmax', 'size_scaling', 'size', 'fill'])
LINE_PROPERTIES = set(['linewidth', 'linestyle'])
DENSITY_PROPERTIES = set(['dpi', 'stretch', 'density_contrast'])
VISUAL_PROPERTIES = (CMAP_PROPERTIES | MARKER_PROPERTIES | DENSITY_PROPERTIES |
LINE_PROPERTIES | set(['color', 'alpha', 'zorder', 'visible']))
DATA_PROPERTIES = set(['layer', 'x_att', 'y_att', 'cmap_mode', 'size_mode', 'density_map',
'xerr_att', 'yerr_att', 'xerr_visible', 'yerr_visible',
'vector_visible', 'vx_att', 'vy_att', 'vector_arrowhead', 'vector_mode',
'vector_origin', 'line_visible', 'markers_visible', 'vector_scaling'])
def ravel_artists(errorbar_artist):
for artist_container in errorbar_artist:
if artist_container is not None:
for artist in artist_container:
if artist is not None:
yield artist
class InvertedNormalize(Normalize):
def __call__(self, *args, **kwargs):
return 1 - super(InvertedNormalize, self).__call__(*args, **kwargs)
class DensityMapLimits(object):
contrast = 1
def min(self, array):
return 0
def max(self, array):
return 10. ** (np.log10(nanmax(array)) * self.contrast)
def set_mpl_artist_cmap(artist, values, state=None, cmap=None, vmin=None, vmax=None):
if state is not None:
vmin = state.cmap_vmin
vmax = state.cmap_vmax
cmap = state.cmap
if not isinstance(artist, GenericDensityArtist):
artist.set_array(values)
artist.set_cmap(cmap)
if vmin > vmax:
artist.set_clim(vmax, vmin)
artist.set_norm(InvertedNormalize(vmax, vmin))
else:
artist.set_clim(vmin, vmax)
artist.set_norm(Normalize(vmin, vmax))
class ColoredLineCollection(LineCollection):
def __init__(self, x, y, **kwargs):
segments = np.zeros((0, 2, 2))
super(ColoredLineCollection, self).__init__(segments, **kwargs)
self.set_points(x, y)
def set_points(self, x, y, oversample=True):
if len(x) == 0:
self.set_segments(np.zeros((0, 2, 2)))
return
if oversample:
x_fine = np.zeros(len(x) * 2 - 1, dtype=float)
y_fine = np.zeros(len(y) * 2 - 1, dtype=float)
x_fine[::2] = x
x_fine[1::2] = 0.5 * (x[1:] + x[:-1])
y_fine[::2] = y
y_fine[1::2] = 0.5 * (y[1:] + y[:-1])
points = np.array([x_fine, y_fine]).transpose().reshape(-1, 1, 2)
segments = np.concatenate([points[:-1], points[1:]], axis=1)
self.set_segments(segments)
else:
points = np.array([x, y]).transpose()
self.set_segments([points])
def set_linearcolor(self, color=None, data=None, **kwargs):
if color is None:
data_new = np.zeros((len(data) - 1) * 2)
data_new[::2] = data[:-1]
data_new[1::2] = data[1:]
set_mpl_artist_cmap(self, data_new, **kwargs)
else:
if isinstance(color, np.ndarray):
color_new = np.zeros(((color.shape[0] - 1) * 2,) + color.shape[1:])
color_new[::2] = color[:-1]
color_new[1::2] = color[1:]
color = color_new
self.set_array(None)
self.set_color(color)
def plot_colored_line(ax, x, y, c=None, cmap=None, vmin=None, vmax=None, **kwargs):
lc = ColoredLineCollection(x, y, **kwargs)
lc.set_linearcolor(color=c, cmap=cmap, vmin=vmin, vmax=vmax)
ax.add_collection(lc)
return lc
class ScatterLayerArtist(MatplotlibLayerArtist):
_layer_state_cls = ScatterLayerState
_python_exporter = python_export_scatter_layer
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(ScatterLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# Watch for changes in the viewer state which would require the
# layers to be redrawn
self._viewer_state.add_global_callback(self._update_scatter)
self.state.add_global_callback(self._update_scatter)
# Scatter density
self.density_auto_limits = DensityMapLimits()
self._set_axes(axes)
self.errorbar_index = 2
self.vector_index = 3
# NOTE: Matplotlib can't deal with NaN values in errorbar correctly, so
# we need to prefilter values - the following variable is used to store
# the mask for the values we keep, so that we can apply it to the color
# See also https://github.com/matplotlib/matplotlib/issues/13799
self._errorbar_keep = None
def _set_axes(self, axes):
self.axes = axes
self.scatter_artist = self.axes.scatter([], [])
self.plot_artist = self.axes.plot([], [], 'o', mec='none')[0]
self.errorbar_artist = self.axes.errorbar([], [], fmt='none')
self.vector_artist = None
self.line_collection = ColoredLineCollection([], [])
self.axes.add_collection(self.line_collection)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", message='All-NaN slice encountered')
self.density_artist = GenericDensityArtist(self.axes, color='white',
vmin=self.density_auto_limits.min,
vmax=self.density_auto_limits.max,
update_while_panning=False,
histogram2d_func=self.compute_density_map,
label=None)
self.axes.add_artist(self.density_artist)
self.mpl_artists = [self.scatter_artist, self.plot_artist,
self.errorbar_artist, self.vector_artist,
self.line_collection, self.density_artist]
def compute_density_map(self, *args, **kwargs):
try:
density_map = self.state.compute_density_map(*args, **kwargs)
except IncompatibleAttribute:
self.disable_invalid_attributes(self._viewer_state.x_att,
self._viewer_state.y_att)
return np.array([[np.nan]])
else:
self.enable()
return density_map
@defer_draw
def _update_data(self):
# Layer artist has been cleared already
if len(self.mpl_artists) == 0:
return
try:
if not self.state.density_map:
x = ensure_numerical(self.layer[self._viewer_state.x_att].ravel())
if x.dtype.kind == 'M':
x = datetime64_to_mpl(x)
except (IncompatibleAttribute, IndexError):
# The following includes a call to self.clear()
self.disable_invalid_attributes(self._viewer_state.x_att)
return
else:
self.enable()
try:
if not self.state.density_map:
y = ensure_numerical(self.layer[self._viewer_state.y_att].ravel())
if y.dtype.kind == 'M':
y = datetime64_to_mpl(y)
except (IncompatibleAttribute, IndexError):
# The following includes a call to self.clear()
self.disable_invalid_attributes(self._viewer_state.y_att)
return
else:
self.enable()
if self.state.markers_visible:
if self.state.density_map:
# We don't use x, y here because we actually make use of the
# ability of the density artist to call a custom histogram
# method which is defined on this class and does the data
# access.
self.plot_artist.set_data([], [])
self.scatter_artist.set_offsets(np.zeros((0, 2)))
else:
self.density_artist.set_label(None)
if self._use_plot_artist():
# In this case we use Matplotlib's plot function because it has much
# better performance than scatter.
self.plot_artist.set_data(x, y)
else:
offsets = np.vstack((x, y)).transpose()
self.scatter_artist.set_offsets(offsets)
else:
self.plot_artist.set_data([], [])
self.scatter_artist.set_offsets(np.zeros((0, 2)))
if self.state.line_visible:
if self.state.cmap_mode == 'Fixed':
self.line_collection.set_points(x, y, oversample=False)
else:
# In the case where we want to color the line, we need to over
# sample the line by a factor of two so that we can assign the
# correct colors to segments - if we didn't do this, then
# segments on one side of a point would be a different color
# from the other side. With oversampling, we can have half a
# segment on either side of a point be the same color as a
# point
self.line_collection.set_points(x, y)
else:
self.line_collection.set_points([], [])
for eartist in ravel_artists(self.errorbar_artist):
try:
eartist.remove()
except ValueError:
pass
if self.vector_artist is not None:
self.vector_artist.remove()
self.vector_artist = None
if self.state.vector_visible:
if self.state.vx_att is not None and self.state.vy_att is not None:
vx = ensure_numerical(self.layer[self.state.vx_att].ravel())
vy = ensure_numerical(self.layer[self.state.vy_att].ravel())
if self.state.vector_mode == 'Polar':
ang = vx
length = vy
# assume ang is anti clockwise from the x axis
vx = length * np.cos(np.radians(ang))
vy = length * np.sin(np.radians(ang))
else:
vx = None
vy = None
if self.state.vector_arrowhead:
hw = 3
hl = 5
else:
hw = 1
hl = 0
vmax = nanmax(np.hypot(vx, vy))
self.vector_artist = self.axes.quiver(x, y, vx, vy, units='width',
pivot=self.state.vector_origin,
headwidth=hw, headlength=hl,
scale_units='width', angles='xy',
scale=10 / self.state.vector_scaling * vmax
)
self.mpl_artists[self.vector_index] = self.vector_artist
if self.state.xerr_visible or self.state.yerr_visible:
keep = ~np.isnan(x) & ~np.isnan(y)
if self.state.xerr_visible and self.state.xerr_att is not None:
xerr = ensure_numerical(self.layer[self.state.xerr_att].ravel()).copy()
keep &= ~np.isnan(xerr)
else:
xerr = None
if self.state.yerr_visible and self.state.yerr_att is not None:
yerr = ensure_numerical(self.layer[self.state.yerr_att].ravel()).copy()
keep &= ~np.isnan(yerr)
else:
yerr = None
if xerr is not None:
xerr = xerr[keep]
if yerr is not None:
yerr = yerr[keep]
self._errorbar_keep = keep
self.errorbar_artist = self.axes.errorbar(x[keep], y[keep], fmt='none',
xerr=xerr, yerr=yerr
)
self.mpl_artists[self.errorbar_index] = self.errorbar_artist
@defer_draw
def _update_visual_attributes(self, changed, force=False):
if not self.enabled:
return
if self.state.markers_visible:
if self.state.density_map:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.density_artist.set_color(self.state.color)
self.density_artist.set_clim(self.density_auto_limits.min,
self.density_auto_limits.max)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = ensure_numerical(self.layer[self.state.cmap_att].ravel())
set_mpl_artist_cmap(self.density_artist, c, self.state)
if force or 'stretch' in changed:
self.density_artist.set_norm(ImageNormalize(stretch=STRETCHES[self.state.stretch]()))
if force or 'dpi' in changed:
self.density_artist.set_dpi(self._viewer_state.dpi)
if force or 'density_contrast' in changed:
self.density_auto_limits.contrast = self.state.density_contrast
self.density_artist.stale = True
else:
if self._use_plot_artist():
if force or 'color' in changed or 'fill' in changed:
if self.state.fill:
self.plot_artist.set_markeredgecolor('none')
self.plot_artist.set_markerfacecolor(self.state.color)
else:
self.plot_artist.set_markeredgecolor(self.state.color)
self.plot_artist.set_markerfacecolor('none')
if force or 'size' in changed or 'size_scaling' in changed:
self.plot_artist.set_markersize(self.state.size *
self.state.size_scaling)
else:
# TEMPORARY: Matplotlib has a bug that causes set_alpha to
# change the colors back: https://github.com/matplotlib/matplotlib/issues/8953
if 'alpha' in changed:
force = True
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed or 'fill' in changed:
self.scatter_artist.set_array(None)
if self.state.fill:
self.scatter_artist.set_facecolors(self.state.color)
self.scatter_artist.set_edgecolors('none')
else:
self.scatter_artist.set_facecolors('none')
self.scatter_artist.set_edgecolors(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES) or 'fill' in changed:
self.scatter_artist.set_edgecolors(None)
self.scatter_artist.set_facecolors(None)
c = ensure_numerical(self.layer[self.state.cmap_att].ravel())
set_mpl_artist_cmap(self.scatter_artist, c, self.state)
if self.state.fill:
self.scatter_artist.set_edgecolors('none')
else:
colors = self.scatter_artist.get_facecolors()
self.scatter_artist.set_facecolors('none')
self.scatter_artist.set_edgecolors(colors)
if force or any(prop in changed for prop in MARKER_PROPERTIES):
if self.state.size_mode == 'Fixed':
s = self.state.size * self.state.size_scaling
s = broadcast_to(s, self.scatter_artist.get_sizes().shape)
else:
s = ensure_numerical(self.layer[self.state.size_att].ravel())
s = ((s - self.state.size_vmin) /
(self.state.size_vmax - self.state.size_vmin))
# The following ensures that the sizes are in the
# range 3 to 30 before the final size_scaling.
np.clip(s, 0, 1, out=s)
s *= 0.95
s += 0.05
s *= (30 * self.state.size_scaling)
# Note, we need to square here because for scatter, s is actually
# proportional to the marker area, not radius.
self.scatter_artist.set_sizes(s ** 2)
if self.state.line_visible:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.line_collection.set_linearcolor(color=self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
# Higher up we oversampled the points in the line so that
# half a segment on either side of each point has the right
# color, so we need to also oversample the color here.
c = ensure_numerical(self.layer[self.state.cmap_att].ravel())
self.line_collection.set_linearcolor(data=c, state=self.state)
if force or 'linewidth' in changed:
self.line_collection.set_linewidth(self.state.linewidth)
if force or 'linestyle' in changed:
self.line_collection.set_linestyle(self.state.linestyle)
if self.state.vector_visible and self.vector_artist is not None:
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
self.vector_artist.set_array(None)
self.vector_artist.set_color(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = ensure_numerical(self.layer[self.state.cmap_att].ravel())
set_mpl_artist_cmap(self.vector_artist, c, self.state)
if self.state.xerr_visible or self.state.yerr_visible:
for eartist in ravel_artists(self.errorbar_artist):
if self.state.cmap_mode == 'Fixed':
if force or 'color' in changed or 'cmap_mode' in changed:
eartist.set_color(self.state.color)
elif force or any(prop in changed for prop in CMAP_PROPERTIES):
c = ensure_numerical(self.layer[self.state.cmap_att].ravel()).copy()
c = c[self._errorbar_keep]
set_mpl_artist_cmap(eartist, c, self.state)
if force or 'alpha' in changed:
eartist.set_alpha(self.state.alpha)
if force or 'visible' in changed:
eartist.set_visible(self.state.visible)
if force or 'zorder' in changed:
eartist.set_zorder(self.state.zorder)
for artist in [self.scatter_artist, self.plot_artist,
self.vector_artist, self.line_collection,
self.density_artist]:
if artist is None:
continue
if force or 'alpha' in changed:
artist.set_alpha(self.state.alpha)
if force or 'zorder' in changed:
artist.set_zorder(self.state.zorder)
if force or 'visible' in changed:
# We need to hide the density artist if it is not needed because
# otherwise it might still show even if there is no data as the
# neutral/zero color might not be white.
if artist is self.density_artist:
artist.set_visible(self.state.visible and
self.state.density_map and
self.state.markers_visible)
else:
artist.set_visible(self.state.visible)
if self._use_plot_artist():
self.scatter_artist.set_visible(False)
else:
self.plot_artist.set_visible(False)
self.redraw()
@defer_draw
def _update_scatter(self, force=False, **kwargs):
if (self._viewer_state.x_att is None or
self._viewer_state.y_att is None or
self.state.layer is None):
return
changed = set() if force else self.pop_changed_properties()
if force or len(changed & DATA_PROPERTIES) > 0:
self._update_data()
force = True
if force or len(changed & VISUAL_PROPERTIES) > 0:
self._update_visual_attributes(changed, force=force)
def get_layer_color(self):
if self.state.cmap_mode == 'Fixed':
return self.state.color
else:
return self.state.cmap
@defer_draw
def update(self):
self._update_scatter(force=True)
self.redraw()
def remove(self):
super(ScatterLayerArtist, self).remove()
# Clean up the density artist to avoid circular references to do a
# reference to the self.histogram2d method in density artist.
self.density_artist = None
def get_handle_legend(self):
if self.enabled and self.state.visible:
handles = []
if self.state.markers_visible:
if self.state.density_map:
if self.state.cmap_mode == 'Fixed':
color = self.get_layer_color()
else:
color = self.layer.style.color
handle = Line2D([0, ], [0, ], marker=".", linestyle="none",
ms=self.state.size, alpha=self.state.alpha,
color=color)
handles.append(handle) # as placeholder
else:
if self._use_plot_artist():
handles.append(self.plot_artist)
else:
handles.append(self.scatter_artist)
if self.state.line_visible:
handles.append(self.line_collection)
if self.state.vector_visible:
handles.append(self.vector_artist)
if self.state.xerr_visible or self.state.yerr_visible:
handles.append(self.errorbar_artist)
handles = tuple(handles)
if len(handles) > 0:
return handles, self.layer.label, None
else:
return None, None, None
else:
return None, None, None
def _use_plot_artist(self):
res = self.state.cmap_mode == 'Fixed' and self.state.size_mode == 'Fixed'
return res and (not hasattr(self._viewer_state, 'plot_mode') or
not self._viewer_state.plot_mode == 'polar')
glueviz-1.0.1+dfsg.orig/glue/viewers/scatter/viewer.py 0000644 0001750 0001750 00000010774 13752534424 022366 0 ustar noahfx noahfx from glue.core.subset import roi_to_subset_state
from glue.core.util import update_ticks
from glue.core.roi_pretransforms import ProjectionMplTransform
from glue.utils import mpl_to_datetime64
from glue.viewers.scatter.compat import update_scatter_viewer_state
from glue.viewers.matplotlib.mpl_axes import init_mpl
__all__ = ['MatplotlibScatterMixin']
class MatplotlibScatterMixin(object):
def setup_callbacks(self):
self.state.add_callback('x_att', self._update_axes)
self.state.add_callback('y_att', self._update_axes)
self.state.add_callback('x_log', self._update_axes)
self.state.add_callback('y_log', self._update_axes)
self.state.add_callback('plot_mode', self._update_projection)
self._update_axes()
def _update_axes(self, *args):
if self.state.x_att is not None:
# Update ticks, which sets the labels to categories if components are categorical
update_ticks(self.axes, 'x', self.state.x_kinds, self.state.x_log,
self.state.x_categories, projection=self.state.plot_mode)
if self.state.x_log:
self.state.x_axislabel = 'Log ' + self.state.x_att.label
else:
self.state.x_axislabel = self.state.x_att.label
if self.state.y_att is not None:
# Update ticks, which sets the labels to categories if components are categorical
update_ticks(self.axes, 'y', self.state.y_kinds, self.state.y_log,
self.state.y_categories, projection=self.state.plot_mode)
if self.state.y_log:
self.state.y_axislabel = 'Log ' + self.state.y_att.label
else:
self.state.y_axislabel = self.state.y_att.label
self.axes.figure.canvas.draw_idle()
def _update_projection(self, *args):
self.figure.delaxes(self.axes)
_, self.axes = init_mpl(self.figure, projection=self.state.plot_mode)
for layer in self.layers:
layer._set_axes(self.axes)
layer.state.vector_mode = 'Cartesian'
layer.update()
self.axes.callbacks.connect('xlim_changed', self.limits_from_mpl)
self.axes.callbacks.connect('ylim_changed', self.limits_from_mpl)
self.removeToolBar(self.toolbar)
self.initialize_toolbar()
self.update_x_axislabel()
self.update_y_axislabel()
self.update_x_ticklabel()
self.update_y_ticklabel()
# Reset and roundtrip the limits to have reasonable and synced limits when changing
self.state.x_log = self.state.y_log = False
self.state.reset_limits()
self.limits_to_mpl()
self.limits_from_mpl()
self.figure.canvas.draw_idle()
def apply_roi(self, roi, override_mode=None):
# Force redraw to get rid of ROI. We do this because applying the
# subset state below might end up not having an effect on the viewer,
# for example there may not be any layers, or the active subset may not
# be one of the layers. So we just explicitly redraw here to make sure
# a redraw will happen after this method is called.
self.redraw()
if len(self.layers) == 0:
return
x_date = 'datetime' in self.state.x_kinds
y_date = 'datetime' in self.state.y_kinds
if x_date or y_date:
roi = roi.transformed(xfunc=mpl_to_datetime64 if x_date else None,
yfunc=mpl_to_datetime64 if y_date else None)
use_transform = self.state.plot_mode != 'rectilinear'
subset_state = roi_to_subset_state(roi,
x_att=self.state.x_att, x_categories=self.state.x_categories,
y_att=self.state.y_att, y_categories=self.state.y_categories,
use_pretransform=use_transform)
if use_transform:
subset_state.pretransform = ProjectionMplTransform(self.state.plot_mode,
self.axes.get_xlim(),
self.axes.get_ylim(),
self.axes.get_xscale(),
self.axes.get_yscale())
self.apply_subset_state(subset_state, override_mode=override_mode)
@staticmethod
def update_viewer_state(rec, context):
return update_scatter_viewer_state(rec, context)
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/ 0000755 0001750 0001750 00000000000 13752535025 020473 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/tests/ 0000755 0001750 0001750 00000000000 13752535025 021635 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/tests/__init__.py 0000644 0001750 0001750 00000000000 13502206677 023735 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/tests/test_state.py 0000644 0001750 0001750 00000011354 13657331513 024372 0 ustar noahfx noahfx import numpy as np
from numpy.testing import assert_allclose
from glue.core import Data, Coordinates
from glue.core.tests.test_state import clone
from ..state import ProfileViewerState, ProfileLayerState
class SimpleCoordinates(Coordinates):
def __init__(self):
super().__init__(pixel_n_dim=3, world_n_dim=3)
def pixel_to_world_values(self, *args):
return tuple([2.0 * p for p in args])
def world_to_pixel_values(self, *args):
return tuple([0.5 * w for w in args])
@property
def axis_correlation_matrix(self):
matrix = np.zeros((self.world_n_dim, self.pixel_n_dim), dtype=bool)
matrix[2, 2] = True
matrix[0:2, 0:2] = True
return matrix
class TestProfileViewerState:
def setup_method(self, method):
self.data = Data(label='d1')
self.data.coords = SimpleCoordinates()
self.data['x'] = np.arange(24).reshape((3, 4, 2)).astype(float)
self.viewer_state = ProfileViewerState()
self.layer_state = ProfileLayerState(viewer_state=self.viewer_state,
layer=self.data)
self.viewer_state.layers.append(self.layer_state)
self.viewer_state.function = 'mean'
def test_basic(self):
x, y = self.layer_state.profile
assert_allclose(x, [0, 2, 4])
assert_allclose(y, [3.5, 11.5, 19.5])
def test_basic_world(self):
self.viewer_state.x_att = self.data.world_component_ids[0]
x, y = self.layer_state.profile
assert_allclose(x, [0, 2, 4])
assert_allclose(y, [3.5, 11.5, 19.5])
def test_x_att(self):
self.viewer_state.x_att = self.data.pixel_component_ids[0]
x, y = self.layer_state.profile
assert_allclose(x, [0, 1, 2])
assert_allclose(y, [3.5, 11.5, 19.5])
self.viewer_state.x_att = self.data.pixel_component_ids[1]
x, y = self.layer_state.profile
assert_allclose(x, [0, 1, 2, 3])
assert_allclose(y, [8.5, 10.5, 12.5, 14.5])
self.viewer_state.x_att = self.data.pixel_component_ids[2]
x, y = self.layer_state.profile
assert_allclose(x, [0, 1])
assert_allclose(y, [11, 12])
def test_function(self):
self.viewer_state.function = 'mean'
x, y = self.layer_state.profile
assert_allclose(y, [3.5, 11.5, 19.5])
self.viewer_state.function = 'minimum'
x, y = self.layer_state.profile
assert_allclose(y, [0, 8, 16])
self.viewer_state.function = 'maximum'
x, y = self.layer_state.profile
assert_allclose(y, [7, 15, 23])
self.viewer_state.function = 'sum'
x, y = self.layer_state.profile
assert_allclose(y, [28, 92, 156])
self.viewer_state.function = 'median'
x, y = self.layer_state.profile
assert_allclose(y, [3.5, 11.5, 19.5])
def test_subset(self):
subset = self.data.new_subset()
subset.subset_state = self.data.id['x'] > 10
self.layer_state.layer = subset
x, y = self.layer_state.profile
assert_allclose(x, [0, 2, 4])
assert_allclose(y, [np.nan, 13., 19.5])
subset.subset_state = self.data.id['x'] > 100
# TODO: the fact we have to call this isn't ideal
self.layer_state.reset_cache()
x, y = self.layer_state.profile
assert len(x) == 0
assert len(y) == 0
def test_clone(self):
self.viewer_state.x_att = self.data.pixel_component_ids[1]
self.viewer_state.function = 'median'
self.layer_state.attribute = self.data.id['x']
self.layer_state.linewidth = 3
viewer_state_new = clone(self.viewer_state)
assert viewer_state_new.x_att.label == 'Pixel Axis 1 [y]'
assert viewer_state_new.function == 'median'
assert self.layer_state.attribute.label == 'x'
assert self.layer_state.linewidth == 3
def test_limits(self):
self.viewer_state.x_att = self.data.pixel_component_ids[0]
assert self.viewer_state.x_min == -0.5
assert self.viewer_state.x_max == 2.5
self.viewer_state.flip_x()
assert self.viewer_state.x_min == 2.5
assert self.viewer_state.x_max == -0.5
self.viewer_state.x_min = 1
self.viewer_state.x_max = 1.5
assert self.viewer_state.x_min == 1
assert self.viewer_state.x_max == 1.5
self.viewer_state.reset_limits()
assert self.viewer_state.x_min == -0.5
assert self.viewer_state.x_max == 2.5
def test_visible(self):
self.layer_state.visible = False
assert self.layer_state.profile is None
self.layer_state.visible = True
x, y = self.layer_state.profile
assert_allclose(x, [0, 2, 4])
assert_allclose(y, [3.5, 11.5, 19.5])
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/ 0000755 0001750 0001750 00000000000 13752535025 021117 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022261 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/test_mouse_mode.py 0000644 0001750 0001750 00000010146 13605357235 026032 0 ustar noahfx noahfx from unittest.mock import MagicMock
from matplotlib import pyplot as plt
from ..mouse_mode import NavigateMouseMode, RangeMouseMode
def test_navigate_mouse_mode():
callback = MagicMock()
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlim(0, 10)
viewer = MagicMock()
viewer.axes = ax
mode = NavigateMouseMode(viewer, press_callback=callback)
event = MagicMock()
event.xdata = 1.5
event.inaxes = True
mode.press(event)
assert mode.state.x is None
mode.move(event)
assert mode.state.x is None
mode.release(event)
assert mode.state.x is None
mode.activate()
mode.press(event)
assert callback.call_count == 1
assert mode.state.x == 1.5
event.xdata = 2.5
mode.move(event)
assert mode.state.x == 2.5
mode.release(event)
event.xdata = 3.5
mode.move(event)
assert mode.state.x == 2.5
mode.deactivate()
event.xdata = 1.5
mode.press(event)
assert callback.call_count == 1
assert mode.state.x == 2.5
mode.activate()
event.xdata = 3.5
mode.press(event)
assert callback.call_count == 2
assert mode.state.x == 3.5
event.inaxes = False
event.xdata = 4.5
mode.press(event)
assert callback.call_count == 2
assert mode.state.x == 3.5
def test_range_mouse_mode():
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlim(0, 10)
viewer = MagicMock()
viewer.axes = ax
mode = RangeMouseMode(viewer)
event = MagicMock()
event.xdata = 1.5
event.inaxes = True
# Pressing, moving, and releasing doesn't do anything until mode is active
mode.press(event)
assert mode.state.x_min is None
assert mode.state.x_max is None
mode.move(event)
assert mode.state.x_min is None
assert mode.state.x_max is None
mode.release(event)
assert mode.state.x_min is None
assert mode.state.x_max is None
mode.activate()
# Click and drag then creates an interval where x_min is the first value
# that was clicked and x_max is set to the position of the mouse while
# dragging and at the point of releasing.
mode.press(event)
assert mode.state.x_min == 1.5
assert mode.state.x_max == 1.5
event.xdata = 2.5
mode.move(event)
assert mode.state.x_min == 1.5
assert mode.state.x_max == 2.5
event.xdata = 3.5
mode.move(event)
assert mode.state.x_min == 1.5
assert mode.state.x_max == 3.5
mode.release(event)
event.xdata = 4.5
mode.move(event)
assert mode.state.x_min == 1.5
assert mode.state.x_max == 3.5
# Test that we can drag the existing edges by clicking on then
event.xdata = 1.49
mode.press(event)
event.xdata = 1.25
mode.move(event)
assert mode.state.x_min == 1.25
assert mode.state.x_max == 3.5
mode.release(event)
event.xdata = 3.51
mode.press(event)
event.xdata = 4.0
mode.move(event)
assert mode.state.x_min == 1.25
assert mode.state.x_max == 4.0
mode.release(event)
# Test that we can drag the entire interval by clicking inside
event.xdata = 2
mode.press(event)
event.xdata = 3
mode.move(event)
assert mode.state.x_min == 2.25
assert mode.state.x_max == 5.0
mode.release(event)
# Test that x_range works
assert mode.state.x_range == (2.25, 5.0)
# Clicking outside the range starts a new interval
event.xdata = 6
mode.press(event)
event.xdata = 7
mode.move(event)
assert mode.state.x_min == 6
assert mode.state.x_max == 7
mode.release(event)
# Deactivate and activate again to make sure that code for hiding/showing
# artists gets executed
mode.deactivate()
event.xdata = 8
mode.press(event)
assert mode.state.x_min == 6
assert mode.state.x_max == 7
mode.activate()
event.xdata = 9
mode.press(event)
event.xdata = 10
mode.move(event)
assert mode.state.x_min == 9
assert mode.state.x_max == 10
# Check that events outside the axes get ignored
event.inaxes = False
event.xdata = 11
mode.press(event)
assert mode.state.x_min == 9
assert mode.state.x_max == 10
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/test_python_export.py 0000644 0001750 0001750 00000005620 13752534424 026621 0 ustar noahfx noahfx from astropy.utils import NumpyRNGContext
from glue.core import Data, DataCollection
from glue.app.qt.application import GlueApplication
from glue.viewers.matplotlib.qt.tests.test_python_export import BaseTestExportPython, random_with_nan
from glue.viewers.profile.qt import ProfileViewer
from glue.viewers.profile.tests.test_state import SimpleCoordinates
class TestExportPython(BaseTestExportPython):
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 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_legend(self, tmpdir):
self.viewer.state.legend.visible = True
self.assert_same(tmpdir)
def test_color(self, tmpdir):
self.viewer.state.layers[0].color = '#ac0567'
self.assert_same(tmpdir)
def test_linewidth(self, tmpdir):
self.viewer.state.layers[0].linewidth = 7.25
self.assert_same(tmpdir)
def test_max(self, tmpdir):
self.viewer.state.function = 'maximum'
self.assert_same(tmpdir)
def test_min(self, tmpdir):
self.viewer.state.function = 'minimum'
self.assert_same(tmpdir)
def test_mean(self, tmpdir):
self.viewer.state.function = 'mean'
self.assert_same(tmpdir)
def test_median(self, tmpdir):
self.viewer.state.function = 'median'
self.assert_same(tmpdir)
def test_sum(self, tmpdir):
self.viewer.state.function = 'sum'
self.assert_same(tmpdir)
def test_normalization(self, tmpdir):
self.viewer.state.normalize = True
self.assert_same(tmpdir)
def test_subset(self, tmpdir):
self.viewer.state.function = 'mean'
self.data_collection.new_subset_group('mysubset', self.data.id['x'] > 0.25)
self.assert_same(tmpdir)
def test_subset_legend(self, tmpdir):
self.viewer.state.legend.visible = True
self.viewer.state.function = 'mean'
self.viewer.state.layers[0].linewidth = 7.25
self.data_collection.new_subset_group('mysubset', self.data.id['x'] > 0.25)
self.assert_same(tmpdir)
def test_xatt(self, tmpdir):
self.viewer.x_att = self.data.pixel_component_ids[1]
self.assert_same(tmpdir)
def test_profile_att(self, tmpdir):
self.viewer.layers[0].state.attribute = self.data.id['y']
self.assert_same(tmpdir)
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/test_profile_tools.py 0000644 0001750 0001750 00000020050 13612627503 026545 0 ustar noahfx noahfx import pytest
import numpy as np
from numpy.testing import assert_allclose
from glue.core import Data
from glue.tests.helpers import PYSIDE2_INSTALLED # noqa
from glue.app.qt import GlueApplication
from glue.utils import nanmean
from glue.utils.qt import process_events
from glue.viewers.image.state import AggregateSlice
from glue.viewers.image.qt import ImageViewer
from glue.viewers.profile.tests.test_state import SimpleCoordinates
from ..data_viewer import ProfileViewer
class TestProfileTools(object):
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 teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_navigate_sync_image(self):
self.viewer.add_data(self.data)
image_viewer = self.app.new_data_viewer(ImageViewer)
image_viewer.add_data(self.data)
assert image_viewer.state.slices == (0, 0, 0)
self.viewer.state.x_att = self.data.pixel_component_ids[0]
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
self.viewer.layers[0].wait()
process_events()
x, y = self.viewer.axes.transData.transform([[1, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
self.viewer.axes.figure.canvas.button_release_event(x, y, 1)
assert image_viewer.state.slices == (1, 0, 0)
self.viewer.state.x_att = self.data.world_component_ids[0]
x, y = self.viewer.axes.transData.transform([[10, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
self.viewer.axes.figure.canvas.button_release_event(x, y, 1)
assert image_viewer.state.slices == (5, 0, 0)
@pytest.mark.skipif('PYSIDE2_INSTALLED')
def test_fit_polynomial(self):
# TODO: need to deterministically set to polynomial fitter
self.viewer.add_data(self.data)
self.profile_tools.ui.tabs.setCurrentIndex(1)
# First try in pixel coordinates
self.viewer.state.x_att = self.data.pixel_component_ids[0]
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
self.viewer.layers[0].wait()
process_events()
x, y = self.viewer.axes.transData.transform([[0.9, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
x, y = self.viewer.axes.transData.transform([[15.1, 4]])[0]
self.viewer.axes.figure.canvas.motion_notify_event(x, y, 1)
assert_allclose(self.profile_tools.rng_mode.state.x_range, (0.9, 15.1))
self.profile_tools.ui.button_fit.click()
self.profile_tools.wait_for_fit()
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
process_events()
pixel_log = self.profile_tools.text_log.toPlainText().splitlines()
assert pixel_log[0] == 'd1'
assert pixel_log[1] == 'Coefficients:'
assert pixel_log[-2] == '8.000000e+00'
assert pixel_log[-1] == '3.500000e+00'
self.profile_tools.ui.button_clear.click()
assert self.profile_tools.text_log.toPlainText() == ''
# Next, try in world coordinates
self.viewer.state.x_att = self.data.world_component_ids[0]
x, y = self.viewer.axes.transData.transform([[1.9, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
x, y = self.viewer.axes.transData.transform([[30.1, 4]])[0]
self.viewer.axes.figure.canvas.motion_notify_event(x, y, 1)
assert_allclose(self.profile_tools.rng_mode.state.x_range, (1.9, 30.1))
self.profile_tools.ui.button_fit.click()
self.profile_tools.wait_for_fit()
process_events()
world_log = self.profile_tools.text_log.toPlainText().splitlines()
assert world_log[0] == 'd1'
assert world_log[1] == 'Coefficients:'
assert world_log[-2] == '4.000000e+00'
assert world_log[-1] == '3.500000e+00'
def test_collapse(self):
self.viewer.add_data(self.data)
image_viewer = self.app.new_data_viewer(ImageViewer)
image_viewer.add_data(self.data)
self.profile_tools.ui.tabs.setCurrentIndex(2)
# First try in pixel coordinates
self.viewer.state.x_att = self.data.pixel_component_ids[0]
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
self.viewer.layers[0].wait()
process_events()
x, y = self.viewer.axes.transData.transform([[0.9, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
x, y = self.viewer.axes.transData.transform([[15.1, 4]])[0]
self.viewer.axes.figure.canvas.motion_notify_event(x, y, 1)
self.profile_tools.ui.button_collapse.click()
assert isinstance(image_viewer.state.slices[0], AggregateSlice)
assert image_viewer.state.slices[0].slice.start == 1
assert image_viewer.state.slices[0].slice.stop == 15
assert image_viewer.state.slices[0].center == 0
assert image_viewer.state.slices[0].function is nanmean
# Next, try in world coordinates
self.viewer.state.x_att = self.data.world_component_ids[0]
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
self.viewer.layers[0].wait()
process_events()
x, y = self.viewer.axes.transData.transform([[1.9, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
x, y = self.viewer.axes.transData.transform([[30.1, 4]])[0]
self.viewer.axes.figure.canvas.motion_notify_event(x, y, 1)
self.profile_tools.ui.button_collapse.click()
assert isinstance(image_viewer.state.slices[0], AggregateSlice)
assert image_viewer.state.slices[0].slice.start == 1
assert image_viewer.state.slices[0].slice.stop == 15
assert image_viewer.state.slices[0].center == 0
assert image_viewer.state.slices[0].function is nanmean
def test_collapse_reverse(self, capsys):
# Regression test for a bug that caused collapsing to fail if selecting
# the range in the reverse direction.
self.viewer.add_data(self.data)
image_viewer = self.app.new_data_viewer(ImageViewer)
image_viewer.add_data(self.data)
self.profile_tools.ui.tabs.setCurrentIndex(2)
self.viewer.state.x_att = self.data.pixel_component_ids[0]
# Force events to be processed to make sure that the callback functions
# for the computation thread are executed (since they rely on signals)
self.viewer.layers[0].wait()
process_events()
x, y = self.viewer.axes.transData.transform([[15.1, 4]])[0]
self.viewer.axes.figure.canvas.button_press_event(x, y, 1)
x, y = self.viewer.axes.transData.transform([[0.9, 4]])[0]
self.viewer.axes.figure.canvas.motion_notify_event(x, y, 1)
self.profile_tools.ui.button_collapse.click()
process_events()
# We use capsys here because the # error is otherwise only apparent in stderr.
out, err = capsys.readouterr()
assert out.strip() == ""
assert err.strip() == ""
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13502206677 024361 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/data/ 0000755 0001750 0001750 00000000000 13752535025 023172 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/data/profile_v1.glu 0000644 0001750 0001750 00000042443 13644362032 025754 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ProfileLayerState",
"ProfileLayerState_0",
"ProfileLayerState_1"
]
},
"CallbackList_0": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ProfileLayerState_2",
"ProfileLayerState_3",
"ProfileLayerState_4"
]
},
"CallbackList_1": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ProfileLayerState_5",
"ProfileLayerState_6",
"ProfileLayerState_7"
]
},
"CallbackList_2": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"ProfileLayerState_8",
"ProfileLayerState_9",
"ProfileLayerState_10"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQB2AHsnZGVzY3InOiAnPGY4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDMsIDQsIDUpLCB9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoAAAAAAAAAAAAAAAAAAPA/AAAAAAAAAEAAAAAAAAAIQAAAAAAAABBAAAAAAAAAFEAAAAAAAAAYQAAAAAAAABxAAAAAAAAAIEAAAAAAAAAiQAAAAAAAACRAAAAAAAAAJkAAAAAAAAAoQAAAAAAAACpAAAAAAAAALEAAAAAAAAAuQAAAAAAAADBAAAAAAAAAMUAAAAAAAAAyQAAAAAAAADNAAAAAAAAANEAAAAAAAAA1QAAAAAAAADZAAAAAAAAAN0AAAAAAAAA4QAAAAAAAADlAAAAAAAAAOkAAAAAAAAA7QAAAAAAAADxAAAAAAAAAPUAAAAAAAAA+QAAAAAAAAD9AAAAAAAAAQEAAAAAAAIBAQAAAAAAAAEFAAAAAAACAQUAAAAAAAABCQAAAAAAAgEJAAAAAAAAAQ0AAAAAAAIBDQAAAAAAAAERAAAAAAACAREAAAAAAAABFQAAAAAAAgEVAAAAAAAAARkAAAAAAAIBGQAAAAAAAAEdAAAAAAACAR0AAAAAAAABIQAAAAAAAgEhAAAAAAAAASUAAAAAAAIBJQAAAAAAAAEpAAAAAAACASkAAAAAAAABLQAAAAAAAgEtAAAAAAAAATEAAAAAAAIBMQAAAAAAAAE1AAAAAAACATUA="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": false
},
"CoordinateComponent_1": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": false
},
"CoordinateComponent_2": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"CoordinateComponent_3": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 1,
"world": true
},
"CoordinateComponent_4": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 2,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 4,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"Pixel Axis 0 [z]",
"Pixel Axis 1 [y]",
"Pixel Axis 2 [x]",
"World 0",
"World 1",
"World 2",
"array_0"
],
"components": [
"CoordinateComponent",
"CoordinateComponent_0",
"CoordinateComponent_1",
"CoordinateComponent_2",
"CoordinateComponent_3",
"CoordinateComponent_4",
"Component"
],
"data": [
"array"
],
"groups": [
"Subset 1",
"Subset 2"
],
"links": [],
"subset_group_count": 2
},
"Pixel Axis 0 [z]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"label": "Pixel Axis 0 [z]"
},
"Pixel Axis 1 [y]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 1,
"label": "Pixel Axis 1 [y]"
},
"Pixel Axis 2 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 2,
"label": "Pixel Axis 2 [x]"
},
"ProfileLayerState": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.8,
"attribute": "array_0",
"color": "st__#919191",
"layer": "array",
"linewidth": 1,
"percentile": 100,
"v_max": 59.0,
"v_min": 19.0,
"visible": true,
"zorder": 1
}
},
"ProfileLayerState_0": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"linewidth": 1,
"percentile": 100,
"v_max": 57.0,
"v_min": 17.0,
"visible": true,
"zorder": 2
}
},
"ProfileLayerState_1": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#33a02c",
"layer": "Subset 2_0",
"linewidth": 1,
"percentile": 100,
"v_max": 58.0,
"v_min": 18.0,
"visible": true,
"zorder": 3
}
},
"ProfileLayerState_10": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#33a02c",
"layer": "Subset 2_0",
"linewidth": 1,
"percentile": 100,
"v_max": 30.5,
"v_min": 30.5,
"visible": false,
"zorder": 3
}
},
"ProfileLayerState_2": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.8,
"attribute": "array_0",
"color": "st__#919191",
"layer": "array",
"linewidth": 1,
"percentile": 100,
"v_max": 59.0,
"v_min": 44.0,
"visible": true,
"zorder": 1
}
},
"ProfileLayerState_3": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"linewidth": 1,
"percentile": 100,
"v_max": 57.0,
"v_min": 42.0,
"visible": false,
"zorder": 2
}
},
"ProfileLayerState_4": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#33a02c",
"layer": "Subset 2_0",
"linewidth": 1,
"percentile": 100,
"v_max": 58.0,
"v_min": 43.0,
"visible": true,
"zorder": 3
}
},
"ProfileLayerState_5": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.8,
"attribute": "array_0",
"color": "st__#919191",
"layer": "array",
"linewidth": 1,
"percentile": 100,
"v_max": 4.0,
"v_min": 0.0,
"visible": true,
"zorder": 1
}
},
"ProfileLayerState_6": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"linewidth": 1,
"percentile": 100,
"v_max": 2.0,
"v_min": 1.0,
"visible": true,
"zorder": 2
}
},
"ProfileLayerState_7": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#33a02c",
"layer": "Subset 2_0",
"linewidth": 1,
"percentile": 100,
"v_max": 3.0,
"v_min": 3.0,
"visible": false,
"zorder": 3
}
},
"ProfileLayerState_8": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.8,
"attribute": "array_0",
"color": "st__#919191",
"layer": "array",
"linewidth": 1,
"percentile": 100,
"v_max": 31.5,
"v_min": 27.5,
"visible": true,
"zorder": 1
}
},
"ProfileLayerState_9": {
"_type": "glue.viewers.profile.state.ProfileLayerState",
"values": {
"alpha": 0.5,
"attribute": "array_0",
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"linewidth": 1,
"percentile": 100,
"v_max": 29.5,
"v_min": 28.5,
"visible": false,
"zorder": 2
}
},
"ProfileViewer": {
"_protocol": 1,
"_type": "glue.viewers.profile.qt.data_viewer.ProfileViewer",
"layers": [
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_0"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_1"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__auto",
"function": "st__maximum",
"layers": "CallbackList",
"normalize": false,
"reference_data": "array",
"show_axes": true,
"x_att": "Pixel Axis 0 [z]",
"x_att_pixel": "Pixel Axis 0 [z]",
"x_axislabel": "st__Pixel Axis 0 [z]",
"x_axislabel_size": 10,
"x_axislabel_weight": "st__normal",
"x_log": false,
"x_max": 2.5,
"x_min": -0.5,
"x_ticklabel_size": 8,
"y_axislabel": "st__Data values",
"y_axislabel_size": 10,
"y_axislabel_weight": "st__normal",
"y_log": false,
"y_max": 63.0,
"y_min": 13.0,
"y_ticklabel_size": 8
}
}
},
"ProfileViewer_0": {
"_protocol": 1,
"_type": "glue.viewers.profile.qt.data_viewer.ProfileViewer",
"layers": [
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_2"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_3"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_4"
}
],
"pos": [
600,
1
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__auto",
"function": "st__maximum",
"layers": "CallbackList_0",
"normalize": true,
"reference_data": "array",
"show_axes": true,
"x_att": "Pixel Axis 1 [y]",
"x_att_pixel": "Pixel Axis 1 [y]",
"x_axislabel": "st__Pixel Axis 1 [y]",
"x_axislabel_size": 10,
"x_axislabel_weight": "st__normal",
"x_log": false,
"x_max": 3.5,
"x_min": -0.5,
"x_ticklabel_size": 8,
"y_axislabel": "st__Normalized data values",
"y_axislabel_size": 10,
"y_axislabel_weight": "st__normal",
"y_log": false,
"y_max": 1.1,
"y_min": -0.1,
"y_ticklabel_size": 8
}
}
},
"ProfileViewer_1": {
"_protocol": 1,
"_type": "glue.viewers.profile.qt.data_viewer.ProfileViewer",
"layers": [
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_5"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_6"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_7"
}
],
"pos": [
0,
400
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__auto",
"function": "st__minimum",
"layers": "CallbackList_1",
"normalize": false,
"reference_data": "array",
"show_axes": true,
"x_att": "Pixel Axis 2 [x]",
"x_att_pixel": "Pixel Axis 2 [x]",
"x_axislabel": "st__Pixel Axis 2 [x]",
"x_axislabel_size": 10,
"x_axislabel_weight": "st__normal",
"x_log": false,
"x_max": 4.5,
"x_min": -0.5,
"x_ticklabel_size": 8,
"y_axislabel": "st__Data values",
"y_axislabel_size": 10,
"y_axislabel_weight": "st__normal",
"y_log": false,
"y_max": 4.4,
"y_min": -0.4,
"y_ticklabel_size": 8
}
}
},
"ProfileViewer_2": {
"_protocol": 1,
"_type": "glue.viewers.profile.qt.data_viewer.ProfileViewer",
"layers": [
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_8"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_9"
},
{
"_type": "glue.viewers.profile.layer_artist.ProfileLayerArtist",
"state": "ProfileLayerState_10"
}
],
"pos": [
600,
400
],
"session": "Session",
"size": [
600,
400
],
"state": {
"values": {
"aspect": "st__auto",
"function": "st__mean",
"layers": "CallbackList_2",
"normalize": false,
"reference_data": "array",
"show_axes": true,
"x_att": "Pixel Axis 2 [x]",
"x_att_pixel": "Pixel Axis 2 [x]",
"x_axislabel": "st__Pixel Axis 2 [x]",
"x_axislabel_size": 10,
"x_axislabel_weight": "st__normal",
"x_log": false,
"x_max": 9.5,
"x_min": -5.5,
"x_ticklabel_size": 8,
"y_axislabel": "st__Data values",
"y_axislabel_size": 10,
"y_axislabel_weight": "st__normal",
"y_log": false,
"y_max": 31.9,
"y_min": 27.1,
"y_ticklabel_size": 8
}
}
},
"RangeSubsetState": {
"_type": "glue.core.subset.RangeSubsetState",
"att": "Pixel Axis 2 [x]",
"hi": 2.2825159914712154,
"lo": 0.9925373134328361
},
"RangeSubsetState_0": {
"_type": "glue.core.subset.RangeSubsetState",
"att": "Pixel Axis 2 [x]",
"hi": 3.2633262260127935,
"lo": 2.932835820895522
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RangeSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 2.5,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1_0"
]
},
"Subset 1_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 2.5,
"marker": "o",
"markersize": 7
}
},
"Subset 2": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 2",
"state": "RangeSubsetState_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 2.5,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 2_0"
]
},
"Subset 2_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 2",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#33a02c",
"linestyle": "solid",
"linewidth": 2.5,
"marker": "o",
"markersize": 7
}
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 0"
},
"World 1": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 1"
},
"World 2": {
"_type": "glue.core.component_id.ComponentID",
"label": "World 2"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue_plotly",
"glue.plugins.export_d3po",
"glue.plugins.tools",
"glue_vispy_viewers.scatter",
"glue.plugins.wcs_autolinking",
"glue.viewers.image.qt",
"glue.viewers.scatter.qt",
"glue.viewers.profile.qt",
"glue.io.formats.fits",
"glue.plugins.tools.pv_slicer",
"glue.plugins.dendro_viewer.qt",
"glue.core.data_exporters",
"glue.viewers.table.qt",
"glue.viewers.histogram.qt",
"glue.plugins.coordinate_helpers",
"glue_vispy_viewers.volume",
"glue.plugins.data_factories.spectral_cube"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"ProfileViewer",
"ProfileViewer_0",
"ProfileViewer_1",
"ProfileViewer_2"
]
]
},
"array": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"Pixel Axis 0 [z]",
"CoordinateComponent"
],
[
"Pixel Axis 1 [y]",
"CoordinateComponent_0"
],
[
"Pixel Axis 2 [x]",
"CoordinateComponent_1"
],
[
"World 0",
"CoordinateComponent_2"
],
[
"World 1",
"CoordinateComponent_3"
],
[
"World 2",
"CoordinateComponent_4"
],
[
"array_0",
"Component"
]
],
"coords": "Coordinates",
"label": "array",
"meta": {
"_type": "collections.OrderedDict",
"contents": {}
},
"primary_owner": [
"Pixel Axis 0 [z]",
"Pixel Axis 1 [y]",
"Pixel Axis 2 [x]",
"World 0",
"World 1",
"World 2",
"array_0"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "#919191",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1_0",
"Subset 2_0"
],
"uuid": "bcc66633-1537-48a3-8710-96e303bf6a6e"
},
"array_0": {
"_type": "glue.core.component_id.ComponentID",
"label": "array"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000023131 13612622074 026160 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import os
import pytest
import numpy as np
from numpy.testing import assert_equal, assert_allclose
from glue.core import Data
from glue.core.roi import XRangeROI
from glue.core.subset import SliceSubsetState
from glue.app.qt import GlueApplication
from glue.core.component_link import ComponentLink
from glue.viewers.matplotlib.qt.tests.test_data_viewer import BaseTestMatplotlibDataViewer
from glue.core.coordinates import IdentityCoordinates
from glue.viewers.profile.tests.test_state import SimpleCoordinates
from glue.core.tests.test_state import clone
from glue.core.state import GlueUnSerializer
from ..data_viewer import ProfileViewer
DATA = os.path.join(os.path.dirname(__file__), 'data')
class TestProfileCommon(BaseTestMatplotlibDataViewer):
def init_data(self):
return Data(label='d1',
x=np.random.random(24).reshape((3, 4, 2)))
viewer_cls = ProfileViewer
@pytest.mark.skip()
def test_double_add_ignored(self):
pass
class TestProfileViewer(object):
def setup_method(self, method):
self.data = Data(label='d1')
self.data.coords = SimpleCoordinates()
self.data['x'] = np.arange(24).reshape((3, 4, 2))
self.data2 = Data(label='d2')
self.data2['y'] = np.arange(24).reshape((3, 4, 2))
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.data2)
self.viewer = self.app.new_data_viewer(ProfileViewer)
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_functions(self):
self.viewer.add_data(self.data)
self.viewer.state.function = 'mean'
assert len(self.viewer.layers) == 1
layer_artist = self.viewer.layers[0]
assert_allclose(layer_artist.state.profile[0], [0, 2, 4])
assert_allclose(layer_artist.state.profile[1], [3.5, 11.5, 19.5])
def test_incompatible(self):
self.viewer.add_data(self.data)
data2 = Data(y=np.random.random((3, 4, 2)))
self.data_collection.append(data2)
self.viewer.add_data(data2)
assert len(self.viewer.layers) == 2
assert self.viewer.layers[0].enabled
assert not self.viewer.layers[1].enabled
def test_selection(self):
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.pixel_component_ids[0]
roi = XRangeROI(0.9, 2.1)
self.viewer.apply_roi(roi)
assert len(self.data.subsets) == 1
assert_equal(self.data.subsets[0].to_mask()[:, 0, 0], [0, 1, 1])
self.viewer.state.x_att = self.data.world_component_ids[0]
roi = XRangeROI(1.9, 3.1)
self.viewer.apply_roi(roi)
assert len(self.data.subsets) == 1
assert_equal(self.data.subsets[0].to_mask()[:, 0, 0], [0, 1, 0])
def test_enabled_layers(self):
data2 = Data(label='d1', y=np.arange(24).reshape((3, 4, 2)),
coords=IdentityCoordinates(n_dim=3))
self.data_collection.append(data2)
self.viewer.add_data(self.data)
self.viewer.add_data(data2)
assert self.viewer.layers[0].enabled
assert not self.viewer.layers[1].enabled
self.data_collection.add_link(ComponentLink([data2.world_component_ids[1]], self.data.world_component_ids[0], using=lambda x: 2 * x))
assert self.viewer.layers[0].enabled
assert self.viewer.layers[1].enabled
def test_slice_subset_state(self):
self.viewer.add_data(self.data)
subset = self.data.new_subset()
subset.subset_state = SliceSubsetState(self.data, [slice(1, 2), slice(None)])
assert self.viewer.layers[0].enabled
assert self.viewer.layers[1].enabled
def test_clone(self):
# Regression test for a bug that meant that deserializing a profile
# viewer resulted in disabled layers
self.viewer.add_data(self.data)
subset = self.data.new_subset()
subset.subset_state = SliceSubsetState(self.data, [slice(1, 2), slice(None)])
app = clone(self.app)
assert app.viewers[0][0].layers[0].enabled
assert app.viewers[0][0].layers[1].enabled
app.close()
def test_incompatible_on_add(self):
# Regression test for a bug when adding a dataset to a profile viewer
# with a single incompatible subset.
subset_state = SliceSubsetState(self.data, [slice(1, 2), slice(None)])
self.data_collection.new_subset_group(subset_state=subset_state, label='s1')
data2 = Data(x=[[2, 3], [4, 3]], label='d2')
self.data_collection.append(data2)
self.viewer.add_data(data2)
def test_dependent_axes(self):
# Make sure that if we pick a world component that has correlations with
# others and is not lined up with the pixel grid, a warning is shown.
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.pixel_component_ids[0]
assert self.viewer.options_widget().ui.text_warning.text() == ''
self.viewer.state.x_att = self.data.pixel_component_ids[1]
assert self.viewer.options_widget().ui.text_warning.text() == ''
self.viewer.state.x_att = self.data.pixel_component_ids[2]
assert self.viewer.options_widget().ui.text_warning.text() == ''
self.viewer.state.x_att = self.data.world_component_ids[0]
assert self.viewer.options_widget().ui.text_warning.text() == ''
self.viewer.state.x_att = self.data.world_component_ids[1]
assert self.viewer.options_widget().ui.text_warning.text() != ''
self.viewer.state.x_att = self.data.world_component_ids[2]
assert self.viewer.options_widget().ui.text_warning.text() != ''
def test_multiple_data(self, tmpdir):
# Regression test for issues when multiple datasets are present
# and the reference data is not the default one.
self.viewer.add_data(self.data)
self.viewer.add_data(self.data2)
assert self.viewer.layers[0].enabled
assert not self.viewer.layers[1].enabled
# Make sure that when changing the reference data, which layer
# is enabled changes.
self.viewer.state.reference_data = self.data2
assert not self.viewer.layers[0].enabled
assert self.viewer.layers[1].enabled
# Make sure that everything works fine after saving/reloading
filename = tmpdir.join('test_multiple_data.glu').strpath
self.session.application.save_session(filename)
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
viewer = ga.viewers[0][0]
assert not viewer.layers[0].enabled
assert viewer.layers[1].enabled
ga.close()
@pytest.mark.parametrize('protocol', [1])
def test_session_back_compat(self, protocol):
filename = os.path.join(DATA, 'profile_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'array'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 3
assert viewer1.state.x_att_pixel is dc[0].pixel_component_ids[0]
assert_allclose(viewer1.state.x_min, -0.5)
assert_allclose(viewer1.state.x_max, 2.5)
assert_allclose(viewer1.state.y_min, 13)
assert_allclose(viewer1.state.y_max, 63)
assert viewer1.state.function == 'maximum'
assert not viewer1.state.normalize
assert viewer1.state.layers[0].visible
assert viewer1.state.layers[1].visible
assert viewer1.state.layers[2].visible
viewer2 = ga.viewers[0][1]
assert viewer2.state.x_att_pixel is dc[0].pixel_component_ids[1]
assert_allclose(viewer2.state.x_min, -0.5)
assert_allclose(viewer2.state.x_max, 3.5)
assert_allclose(viewer2.state.y_min, -0.1)
assert_allclose(viewer2.state.y_max, 1.1)
assert viewer2.state.function == 'maximum'
assert viewer2.state.normalize
assert viewer2.state.layers[0].visible
assert not viewer2.state.layers[1].visible
assert viewer2.state.layers[2].visible
viewer3 = ga.viewers[0][2]
assert viewer3.state.x_att_pixel is dc[0].pixel_component_ids[2]
assert_allclose(viewer3.state.x_min, -0.5)
assert_allclose(viewer3.state.x_max, 4.5)
assert_allclose(viewer3.state.y_min, -0.4)
assert_allclose(viewer3.state.y_max, 4.4)
assert viewer3.state.function == 'minimum'
assert not viewer3.state.normalize
assert viewer3.state.layers[0].visible
assert viewer3.state.layers[1].visible
assert not viewer3.state.layers[2].visible
viewer4 = ga.viewers[0][3]
assert viewer4.state.x_att_pixel is dc[0].pixel_component_ids[2]
assert_allclose(viewer4.state.x_min, -5.5)
assert_allclose(viewer4.state.x_max, 9.5)
assert_allclose(viewer4.state.y_min, 27.1)
assert_allclose(viewer4.state.y_max, 31.9)
assert viewer4.state.function == 'mean'
assert not viewer4.state.normalize
assert viewer4.state.layers[0].visible
assert not viewer4.state.layers[1].visible
assert not viewer4.state.layers[2].visible
ga.close()
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/data_viewer.py 0000644 0001750 0001750 00000002345 13641107542 023763 0 ustar noahfx noahfx from glue.utils import defer_draw, decorate_all_methods
from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.profile.qt.layer_style_editor import ProfileLayerStyleEditor
from glue.viewers.profile.qt.layer_artist import QThreadedProfileLayerArtist
from glue.viewers.profile.qt.options_widget import ProfileOptionsWidget
from glue.viewers.profile.state import ProfileViewerState
from glue.viewers.profile.qt.profile_tools import ProfileAnalysisTool # noqa
from glue.viewers.profile.viewer import MatplotlibProfileMixin
__all__ = ['ProfileViewer']
@decorate_all_methods(defer_draw)
class ProfileViewer(MatplotlibProfileMixin, MatplotlibDataViewer):
LABEL = '1D Profile'
_layer_style_widget_cls = ProfileLayerStyleEditor
_state_cls = ProfileViewerState
_options_cls = ProfileOptionsWidget
_data_artist_cls = QThreadedProfileLayerArtist
_subset_artist_cls = QThreadedProfileLayerArtist
large_data_size = 1e8
allow_duplicate_data = True
tools = ['select:xrange', 'profile-analysis']
def __init__(self, session, parent=None, state=None):
MatplotlibDataViewer.__init__(self, session, parent=parent, state=state)
MatplotlibProfileMixin.setup_callbacks(self)
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/options_widget.ui 0000644 0001750 0001750 00000026101 13661230662 024512 0 ustar noahfx noahfx
Widget
0
0
269
418
1D Profile
5
5
5
5
5
-
0
General
10
10
10
10
10
5
-
75
true
reference
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
QComboBox::AdjustToMinimumContentsLength
-
75
true
function
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
x axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
Qt::Horizontal
40
5
-
75
true
normalize
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
color: rgb(255, 33, 28)
Warning
Qt::AlignCenter
true
-
QComboBox::AdjustToMinimumContentsLength
-
Qt::Vertical
20
40
Limits
10
10
10
10
10
5
-
padding: 0px
⇄
-
-
-
-
75
true
x axis
-
75
true
y axis
-
Qt::Vertical
20
40
-
-
Qt::Horizontal
40
5
-
log
true
-
log
true
bool_x_log
valuetext_x_max
button_flip_x
valuetext_x_min
valuetext_y_min
valuetext_y_max
bool_y_log
label_2
label_5
verticalSpacer
horizontalSpacer_2
Axes
5
5
5
5
-
Legend
5
5
5
5
-
AxesEditorWidget
QWidget
glue.viewers.matplotlib.qt.axes_editor
LegendEditorWidget
QWidget
glue.viewers.matplotlib.qt.legend_editor
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/__init__.py 0000644 0001750 0001750 00000000205 13502206677 023226 0 ustar noahfx noahfx from .data_viewer import ProfileViewer # noqa
def setup():
from glue.config import qt_client
qt_client.add(ProfileViewer)
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/layer_artist.py 0000644 0001750 0001750 00000004401 13641154460 024167 0 ustar noahfx noahfx import time
from glue.viewers.profile.layer_artist import ProfileLayerArtist
from glue.viewers.matplotlib.qt.compute_worker import ComputeWorker
from glue.utils import defer_draw
__all__ = ['QThreadedProfileLayerArtist']
class QThreadedProfileLayerArtist(ProfileLayerArtist):
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(QThreadedProfileLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
self.setup_thread()
def wait(self):
# Wait 0.5 seconds to make sure that the computation has properly started
time.sleep(0.5)
while self._worker.running:
time.sleep(1 / 25)
from glue.utils.qt import process_events
process_events()
def remove(self):
super(QThreadedProfileLayerArtist, self).remove()
if self._worker is not None:
self._worker.work_queue.put('stop')
self._worker.exit()
# Need to wait otherwise the thread will be destroyed while still
# running, causing a segmentation fault
self._worker.wait()
self._worker = None
@property
def is_computing(self):
return self._worker is not None and self._worker.running
def setup_thread(self):
self._worker = ComputeWorker(self._calculate_profile_thread)
self._worker.compute_end.connect(self._calculate_profile_postthread)
self._worker.compute_error.connect(self._calculate_profile_error)
self._worker.compute_start.connect(self.notify_start_computation)
self._worker.start()
@defer_draw
def _calculate_profile(self, reset=False):
if self.state.layer is not None and self.state.layer.size > 1e7:
self._worker.work_queue.put(reset)
else:
super(QThreadedProfileLayerArtist, self)._calculate_profile(reset=reset)
def _calculate_profile_postthread(self):
# If the worker has started running again, we should stop at this point
# since this function will get called again.
if self._worker is not None and self._worker.running:
return
super(QThreadedProfileLayerArtist, self)._calculate_profile_postthread()
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/options_widget.py 0000644 0001750 0001750 00000003745 13752534424 024542 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from glue.core.coordinate_helpers import dependent_axes
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
__all__ = ['ProfileOptionsWidget']
WARNING_TEXT = ("Warning: the coordinate '{label}' is not aligned with pixel "
"grid, so the values shown on the x-axis are approximate.")
class ProfileOptionsWidget(QtWidgets.QWidget):
def __init__(self, viewer_state, session, parent=None):
super(ProfileOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self._connections = autoconnect_callbacks_to_qt(viewer_state, self.ui)
self._connections_axes = autoconnect_callbacks_to_qt(viewer_state, self.ui.axes_editor.ui)
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections_legend = autoconnect_callbacks_to_qt(viewer_state.legend, self.ui.legend_editor.ui, connect_kwargs)
self.viewer_state = viewer_state
self.session = session
self.viewer_state.add_callback('x_att', self._on_attribute_change)
self.ui.text_warning.hide()
def _on_attribute_change(self, *args):
if (self.viewer_state.reference_data is None or
self.viewer_state.x_att_pixel is None or
self.viewer_state.x_att is self.viewer_state.x_att_pixel):
self.ui.text_warning.hide()
return
world_warning = len(dependent_axes(self.viewer_state.reference_data.coords,
self.viewer_state.x_att_pixel.axis)) > 1
if world_warning:
self.ui.text_warning.show()
self.ui.text_warning.setText(WARNING_TEXT.format(label=self.viewer_state.x_att.label))
else:
self.ui.text_warning.hide()
self.ui.text_warning.setText('')
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/mouse_mode.py 0000644 0001750 0001750 00000014566 13657331513 023641 0 ustar noahfx noahfx from echo import CallbackProperty, delay_callback
from glue.core.state_objects import State
from glue.viewers.matplotlib.mouse_mode import MouseMode
__all__ = ['NavigateMouseMode', 'RangeMouseMode']
COLOR = (0.0, 0.25, 0.7)
class NavigationModeState(State):
x = CallbackProperty(None)
class NavigateMouseMode(MouseMode):
def __init__(self, viewer, press_callback=None):
super(NavigateMouseMode, self).__init__(viewer)
self.state = NavigationModeState()
self.state.add_callback('x', self._update_artist)
self.pressed = False
self.active = False
self._press_callback = press_callback
def press(self, event):
if not self.active or not event.inaxes:
return
if self._press_callback is not None:
self._press_callback()
self.pressed = True
self.state.x = event.xdata
def move(self, event):
if not self.active or not self.pressed or not event.inaxes:
return
self.state.x = event.xdata
def release(self, event):
if not self.active:
return
self.pressed = False
def _update_artist(self, *args):
if hasattr(self, '_line'):
if self.state.x is None:
self._line.set_visible(False)
else:
self._line.set_visible(True)
self._line.set_data([self.state.x, self.state.x], [0, 1])
else:
if self.state.x is not None:
self._line = self._axes.axvline(self.state.x, color=COLOR)
self._canvas.draw_idle()
def deactivate(self):
if hasattr(self, '_line'):
self._line.set_visible(False)
self._canvas.draw_idle()
super(NavigateMouseMode, self).deactivate()
self.active = False
def activate(self):
if hasattr(self, '_line'):
self._line.set_visible(True)
self._canvas.draw_idle()
super(NavigateMouseMode, self).activate()
self.active = True
def clear(self):
self.state.x = None
class RangeModeState(State):
x_min = CallbackProperty(None)
x_max = CallbackProperty(None)
@property
def x_range(self):
return self.x_min, self.x_max
PICK_THRESH = 0.02
class RangeMouseMode(MouseMode):
def __init__(self, viewer):
super(RangeMouseMode, self).__init__(viewer)
self.state = RangeModeState()
self.state.add_callback('x_min', self._update_artist)
self.state.add_callback('x_max', self._update_artist)
self.pressed = False
self.mode = None
self.move_params = None
self.active = False
def press(self, event):
if not self.active or not event.inaxes:
return
self.pressed = True
x_min, x_max = self._axes.get_xlim()
x_range = abs(x_max - x_min)
if self.state.x_min is None or self.state.x_max is None:
self.mode = 'move-x-max'
with delay_callback(self.state, 'x_min', 'x_max'):
self.state.x_min = event.xdata
self.state.x_max = event.xdata
elif abs(event.xdata - self.state.x_min) / x_range < PICK_THRESH:
self.mode = 'move-x-min'
elif abs(event.xdata - self.state.x_max) / x_range < PICK_THRESH:
self.mode = 'move-x-max'
elif (event.xdata > self.state.x_min) is (event.xdata < self.state.x_max):
self.mode = 'move'
self.move_params = (event.xdata, self.state.x_min, self.state.x_max)
else:
self.mode = 'move-x-max'
self.state.x_min = event.xdata
def move(self, event):
if not self.active or not self.pressed or not event.inaxes:
return
if self.mode == 'move-x-min':
self.state.x_min = event.xdata
elif self.mode == 'move-x-max':
self.state.x_max = event.xdata
elif self.mode == 'move':
orig_click, orig_x_min, orig_x_max = self.move_params
with delay_callback(self.state, 'x_min', 'x_max'):
self.state.x_min = orig_x_min + (event.xdata - orig_click)
self.state.x_max = orig_x_max + (event.xdata - orig_click)
def release(self, event):
if not self.active:
return
self.pressed = False
self.mode = None
self.move_params
def _update_artist(self, *args):
y_min, y_max = self._axes.get_ylim()
if hasattr(self, '_lines'):
if self.state.x_min is None or self.state.x_max is None:
self._lines[0].set_visible(False)
self._lines[1].set_visible(False)
self._interval.set_visible(False)
else:
self._lines[0].set_data([self.state.x_min, self.state.x_min], [0, 1])
self._lines[1].set_data([self.state.x_max, self.state.x_max], [0, 1])
self._interval.set_xy([[self.state.x_min, 0],
[self.state.x_min, 1],
[self.state.x_max, 1],
[self.state.x_max, 0],
[self.state.x_min, 0]])
else:
if self.state.x_min is not None and self.state.x_max is not None:
self._lines = (self._axes.axvline(self.state.x_min, color=COLOR),
self._axes.axvline(self.state.x_max, color=COLOR))
self._interval = self._axes.axvspan(self.state.x_min,
self.state.x_max,
color=COLOR, alpha=0.05)
self._canvas.draw_idle()
def deactivate(self):
if hasattr(self, '_lines'):
self._lines[0].set_visible(False)
self._lines[1].set_visible(False)
self._interval.set_visible(False)
self._canvas.draw_idle()
super(RangeMouseMode, self).deactivate()
self.active = False
def activate(self):
if hasattr(self, '_lines'):
self._lines[0].set_visible(True)
self._lines[1].set_visible(True)
self._interval.set_visible(True)
self._canvas.draw_idle()
super(RangeMouseMode, self).activate()
self.active = True
def clear(self):
with delay_callback(self.state, 'x_min', 'x_max'):
self.state.x_min = None
self.state.x_max = None
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/profile_tools.py 0000644 0001750 0001750 00000027712 13657331513 024362 0 ustar noahfx noahfx import os
import weakref
import traceback
from collections import OrderedDict
import numpy as np
from qtpy.QtCore import Qt
from qtpy import QtWidgets, QtGui
from glue.utils import color2hex, nanmean, nanmedian, nanmin, nanmax, nansum
from glue.config import fit_plugin, viewer_tool
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
from glue.viewers.profile.qt.mouse_mode import NavigateMouseMode, RangeMouseMode
from glue.core.qt.fitters import FitSettingsWidget
from glue.utils.qt import Worker
from glue.viewers.common.tool import Tool
from glue.viewers.image.state import AggregateSlice
from glue.core.aggregate import mom1, mom2
from glue.core import BaseData, Subset
from glue.viewers.image.qt import ImageViewer
from glue.core.link_manager import is_convertible_to_single_pixel_cid
from echo import SelectionCallbackProperty
from echo.qt import connect_combo_selection
__all__ = ['ProfileTools']
MODES = ['navigate', 'fit', 'collapse']
COLLAPSE_FUNCS = OrderedDict([(nanmean, 'Mean'),
(nanmedian, 'Median'),
(nanmin, 'Minimum'),
(nanmax, 'Maximum'),
(nansum, 'Sum'),
(mom1, 'Moment 1'),
(mom2, 'Moment 2')])
@viewer_tool
class ProfileAnalysisTool(Tool):
action_text = 'Options'
tool_id = 'profile-analysis'
def __init__(self, viewer):
super(ProfileAnalysisTool, self).__init__(viewer)
self._profile_tools = ProfileTools(viewer)
container_widget = QtWidgets.QSplitter(Qt.Horizontal)
plot_widget = viewer.centralWidget()
container_widget.addWidget(plot_widget)
container_widget.addWidget(self._profile_tools)
viewer.setCentralWidget(container_widget)
self._profile_tools.enable()
self._profile_tools.hide()
def activate(self):
if self._profile_tools.isVisible():
self._profile_tools.hide()
else:
self._profile_tools.show()
class ProfileTools(QtWidgets.QWidget):
fit_function = SelectionCallbackProperty()
collapse_function = SelectionCallbackProperty()
def __init__(self, parent=None):
super(ProfileTools, self).__init__(parent=parent)
self._viewer = weakref.ref(parent)
self.ui = load_ui('profile_tools.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tabs)
self.image_viewer = None
@property
def viewer(self):
return self._viewer()
def show(self, *args):
super(ProfileTools, self).show(*args)
self._on_tab_change()
def hide(self, *args):
super(ProfileTools, self).hide(*args)
self.rng_mode.deactivate()
self.nav_mode.deactivate()
def enable(self):
self.nav_mode = NavigateMouseMode(self.viewer,
press_callback=self._on_nav_activate)
self.rng_mode = RangeMouseMode(self.viewer)
self.nav_mode.state.add_callback('x', self._on_slider_change)
self.ui.tabs.setCurrentIndex(0)
self.ui.tabs.currentChanged.connect(self._on_tab_change)
self.ui.button_settings.clicked.connect(self._on_settings)
self.ui.button_fit.clicked.connect(self._on_fit)
self.ui.button_clear.clicked.connect(self._on_clear)
self.ui.button_collapse.clicked.connect(self._on_collapse)
font = QtGui.QFont("Courier")
font.setStyleHint(font.Monospace)
self.ui.text_log.document().setDefaultFont(font)
self.ui.text_log.setLineWrapMode(self.ui.text_log.NoWrap)
self.axes = self.viewer.axes
self.canvas = self.axes.figure.canvas
self._fit_artists = []
ProfileTools.fit_function.set_choices(self, list(fit_plugin))
ProfileTools.fit_function.set_display_func(self, lambda fitter: fitter.label)
self._connection_fit = connect_combo_selection(self, 'fit_function', self.ui.combosel_fit_function)
ProfileTools.collapse_function.set_choices(self, list(COLLAPSE_FUNCS))
ProfileTools.collapse_function.set_display_func(self, COLLAPSE_FUNCS.get)
self._connection_collapse = connect_combo_selection(self, 'collapse_function', self.ui.combosel_collapse_function)
self._toolbar_connected = False
self.viewer.toolbar_added.connect(self._on_toolbar_added)
self.viewer.state.add_callback('x_att', self._on_x_att_change)
def _on_x_att_change(self, *event):
self.nav_mode.clear()
self.rng_mode.clear()
def _on_nav_activate(self, *args):
self._nav_data = self._visible_data()
self._nav_viewers = {}
for data in self._nav_data:
pix_cid = is_convertible_to_single_pixel_cid(data, self.viewer.state.x_att_pixel)
self._nav_viewers[data] = self._viewers_with_data_slice(data, pix_cid)
def _on_slider_change(self, *args):
x = self.nav_mode.state.x
if x is None:
return
for data in self._nav_data:
axis, slc = self._get_axis_and_pixel_slice(data, x)
for viewer in self._nav_viewers[data]:
slices = list(viewer.state.slices)
slices[axis] = slc
viewer.state.slices = tuple(slices)
def _get_axis_and_pixel_slice(self, data, x):
if self.viewer.state.x_att in data.pixel_component_ids:
axis = self.viewer.state.x_att.axis
slc = int(round(x))
else:
pix_cid = is_convertible_to_single_pixel_cid(data, self.viewer.state.x_att_pixel)
axis = pix_cid.axis
axis_view = [0] * data.ndim
axis_view[pix_cid.axis] = slice(None)
axis_values = data[self.viewer.state.x_att, axis_view]
slc = int(np.argmin(np.abs(axis_values - x)))
return axis, slc
def _on_settings(self):
d = FitSettingsWidget(self.fit_function())
d.exec_()
def _on_fit(self):
"""
Fit a model to the data
The fitting happens on a dedicated thread, to keep the UI
responsive
"""
if self.rng_mode.state.x_min is None or self.rng_mode.state.x_max is None:
return
x_range = self.rng_mode.state.x_range
fitter = self.fit_function()
def on_success(result):
fit_results, x, y = result
report = ""
normalize = {}
for layer_artist in fit_results:
report += ("{1}"
"".format(color2hex(layer_artist.state.color),
layer_artist.layer.label))
report += "" + fitter.summarize(fit_results[layer_artist], x, y) + "
"
if self.viewer.state.normalize:
normalize[layer_artist] = layer_artist.state.normalize_values
self._report_fit(report)
self._plot_fit(fitter, fit_results, x, y, normalize)
def on_fail(exc_info):
exc = '\n'.join(traceback.format_exception(*exc_info))
self._report_fit("Error during fitting:\n%s" % exc)
def on_done():
self.ui.button_fit.setText("Fit")
self.ui.button_fit.setEnabled(True)
self.canvas.draw_idle()
self.ui.button_fit.setText("Running...")
self.ui.button_fit.setEnabled(False)
w = Worker(self._fit, fitter, xlim=x_range)
w.result.connect(on_success)
w.error.connect(on_fail)
w.finished.connect(on_done)
self._fit_worker = w # hold onto a reference
w.start()
def wait_for_fit(self):
self._fit_worker.wait()
def _report_fit(self, report):
self.ui.text_log.document().setHtml(report)
def _on_clear(self):
self.ui.text_log.document().setPlainText('')
self._clear_fit()
self.canvas.draw_idle()
def _fit(self, fitter, xlim=None):
# We cycle through all the visible layers and get the plotted data
# for each one of them.
results = {}
for layer in self.viewer.layers:
if layer.enabled and layer.visible:
x, y = layer.state.profile
x = np.asarray(x)
y = np.asarray(y)
keep = (x >= min(xlim)) & (x <= max(xlim))
if len(x) > 0:
results[layer] = fitter.build_and_fit(x[keep], y[keep])
return results, x, y
def _clear_fit(self):
for artist in self._fit_artists[:]:
artist.remove()
self._fit_artists.remove(artist)
def _plot_fit(self, fitter, fit_result, x, y, normalize):
self._clear_fit()
for layer in fit_result:
# y_model = fitter.predict(fit_result[layer], x)
self._fit_artists.append(fitter.plot(fit_result[layer], self.axes, x,
alpha=layer.state.alpha,
linewidth=layer.state.linewidth * 0.5,
color=layer.state.color,
normalize=normalize.get(layer, None))[0])
self.canvas.draw_idle()
def _visible_data(self):
datasets = set()
for layer_artist in self.viewer.layers:
if layer_artist.enabled and layer_artist.visible:
if isinstance(layer_artist.state.layer, BaseData):
datasets.add(layer_artist.state.layer)
elif isinstance(layer_artist.state.layer, Subset):
datasets.add(layer_artist.state.layer.data)
return list(datasets)
def _viewers_with_data_slice(self, data, xatt):
if self.viewer.session.application is None:
return []
viewers = []
for tab in self.viewer.session.application.viewers:
for viewer in tab:
if isinstance(viewer, ImageViewer):
for layer_artist in viewer._layer_artist_container[data]:
if layer_artist.enabled and layer_artist.visible:
if len(viewer.state.slices) >= xatt.axis:
viewers.append(viewer)
return viewers
def _on_collapse(self):
if self.rng_mode.state.x_min is None or self.rng_mode.state.x_max is None:
return
func = self.collapse_function
x_range = self.rng_mode.state.x_range
for data in self._visible_data():
pix_cid = is_convertible_to_single_pixel_cid(data, self.viewer.state.x_att_pixel)
for viewer in self._viewers_with_data_slice(data, pix_cid):
slices = list(viewer.state.slices)
# TODO: don't need to fetch axis twice
axis, imin = self._get_axis_and_pixel_slice(data, x_range[0])
axis, imax = self._get_axis_and_pixel_slice(data, x_range[1])
current_slice = slices[axis]
if isinstance(current_slice, AggregateSlice):
current_slice = current_slice.center
imin, imax = min(imin, imax), max(imin, imax)
slices[axis] = AggregateSlice(slice(imin, imax),
current_slice,
func)
viewer.state.slices = tuple(slices)
@property
def mode(self):
return MODES[self.tabs.currentIndex()]
def _on_toolbar_added(self, *event):
self.viewer.toolbar.tool_activated.connect(self._on_toolbar_activate)
self.viewer.toolbar.tool_deactivated.connect(self._on_tab_change)
def _on_toolbar_activate(self, *event):
self.rng_mode.deactivate()
self.nav_mode.deactivate()
def _on_tab_change(self, *event):
mode = self.mode
if mode == 'navigate':
self.rng_mode.deactivate()
self.nav_mode.activate()
else:
self.rng_mode.activate()
self.nav_mode.deactivate()
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/profile_tools.ui 0000644 0001750 0001750 00000016001 13502206677 024335 0 ustar noahfx noahfx
Form
0
0
293
254
Form
-
1
Navigate
-
Qt::Vertical
20
40
-
<html><head/><body><p>To <span style=" font-weight:600;">slide </span>through any cubes in image viewers that show the same data as the one here, drag the handle from side to side.</p><p>Note that modifying the sliders in the image viewers will not change the slider here or in other viewers.</p></body></html>
Qt::AlignJustify|Qt::AlignVCenter
true
-
Qt::Vertical
20
40
Fit
-
Click and drag in the profile to define the range over which to fit models to the data.
true
-
-
Function:
-
-
-
Settings
-
Qt::Horizontal
40
20
-
Fit
-
Clear
-
Collapse
-
Qt::Vertical
20
40
-
Click and drag in the profile to define the range over which to fit models to the data.
true
-
-
Function:
-
-
-
Qt::Horizontal
40
20
-
Collapse
-
Qt::Horizontal
40
20
-
Qt::Vertical
20
40
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/layer_style_editor.ui 0000644 0001750 0001750 00000012371 13502206677 025365 0 ustar noahfx noahfx
Form
0
0
292
150
Form
5
5
5
5
10
5
-
75
true
attribute
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
2
-
-
padding: 0px
⇄
-
-
Qt::Horizontal
40
5
-
0
0
-
75
true
color
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
-
Qt::Vertical
20
40
-
100
Qt::Horizontal
-
75
true
opacity
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
linewidth
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
limits
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
QComboBox::AdjustToMinimumContentsLength
QColorBox
QLabel
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/qt/layer_style_editor.py 0000644 0001750 0001750 00000002054 13657331513 025374 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui
class ProfileLayerStyleEditor(QtWidgets.QWidget):
def __init__(self, layer, parent=None):
super(ProfileLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
self.viewer_state = layer.state.viewer_state
self.viewer_state.add_callback('normalize', self._on_normalize_change)
self._on_normalize_change()
def _on_normalize_change(self, *event):
self.ui.label_limits.setVisible(self.viewer_state.normalize)
self.ui.valuetext_v_min.setVisible(self.viewer_state.normalize)
self.ui.valuetext_v_max.setVisible(self.viewer_state.normalize)
self.ui.button_flip_limits.setVisible(self.viewer_state.normalize)
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/python_export.py 0000644 0001750 0001750 00000004463 13661230662 023774 0 ustar noahfx noahfx from glue.viewers.common.python_export import serialize_options
from glue.core import Subset
def python_export_profile_layer(layer, *args):
if len(layer.mpl_artists) == 0 or not layer.enabled or not layer.visible:
return [], None
script = ""
imports = ["import numpy as np"]
script += "# Calculate the profile of the data\n"
script += "profile_axis = {0}\n".format(layer._viewer_state.x_att_pixel.axis)
script += "collapsed_axes = tuple(i for i in range(layer_data.ndim) if i != profile_axis)\n"
if isinstance(layer.state.layer, Subset):
script += "base_data = layer_data.data\n"
script += "cid = base_data.find_component_id('{0}')\n".format(layer.state.attribute.label)
script += "profile_values = base_data.compute_statistic('{0}', cid, axis=collapsed_axes, subset_state=layer_data.subset_state)\n\n".format(layer._viewer_state.function)
else:
script += "cid = layer_data.find_component_id('{0}')\n".format(layer.state.attribute.label)
script += "profile_values = layer_data.compute_statistic('{0}', cid, axis=collapsed_axes)\n\n".format(layer._viewer_state.function)
script += "# Extract the values for the x-axis\n"
script += "axis_view = [0] * layer_data.ndim\n"
script += "axis_view[profile_axis] = slice(None)\n"
script += "profile_x_values = layer_data['{0}', tuple(axis_view)]\n".format(layer._viewer_state.x_att)
script += "keep = ~np.isnan(profile_values) & ~np.isnan(profile_x_values)\n\n"
if layer._viewer_state.normalize:
script += "# Normalize the profile data\n"
script += "vmax = np.nanmax(profile_values)\n"
script += "vmin = np.nanmin(profile_values)\n"
script += "profile_values = (profile_values - vmin)/(vmax - vmin)\n\n"
script += "# Plot the profile\n"
plot_options = dict(color=layer.state.color,
linewidth=layer.state.linewidth,
alpha=layer.state.alpha,
zorder=layer.state.zorder,
drawstyle='steps-mid')
script += "handle, = ax.plot(profile_x_values[keep], profile_values[keep], '-', {0})\n".format(serialize_options(plot_options))
script += "legend_handles.append(handle)\n"
script += "legend_labels.append(layer_data.label)\n\n"
return imports, script.strip()
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/state.py 0000644 0001750 0001750 00000026500 13657331513 022170 0 ustar noahfx noahfx from collections import OrderedDict
import numpy as np
from glue.core import Subset
from echo import delay_callback
from glue.viewers.matplotlib.state import (MatplotlibDataViewerState,
MatplotlibLayerState,
DeferredDrawCallbackProperty as DDCProperty,
DeferredDrawSelectionCallbackProperty as DDSCProperty)
from glue.core.data_combo_helper import ManualDataComboHelper, ComponentIDComboHelper
from glue.utils import defer_draw, nanmin, nanmax
from glue.core.link_manager import is_convertible_to_single_pixel_cid
from glue.core.exceptions import IncompatibleDataException
__all__ = ['ProfileViewerState', 'ProfileLayerState']
FUNCTIONS = OrderedDict([('maximum', 'Maximum'),
('minimum', 'Minimum'),
('mean', 'Mean'),
('median', 'Median'),
('sum', 'Sum')])
class ProfileViewerState(MatplotlibDataViewerState):
"""
A state class that includes all the attributes for a Profile viewer.
"""
x_att_pixel = DDCProperty(docstring='The component ID giving the pixel component '
'shown on the x axis')
x_att = DDSCProperty(docstring='The component ID giving the pixel or world component '
'shown on the x axis')
reference_data = DDSCProperty(docstring='The dataset that is used to define the '
'available pixel/world components, and '
'which defines the coordinate frame in '
'which the images are shown')
function = DDSCProperty(docstring='The function to use for collapsing data')
normalize = DDCProperty(False, docstring='Whether to normalize all profiles '
'to the [0:1] range')
# TODO: add function to use
def __init__(self, **kwargs):
super(ProfileViewerState, self).__init__()
self.ref_data_helper = ManualDataComboHelper(self, 'reference_data')
self.add_callback('layers', self._layers_changed)
self.add_callback('reference_data', self._reference_data_changed)
self.add_callback('x_att', self._update_att)
self.add_callback('normalize', self._reset_y_limits)
self.x_att_helper = ComponentIDComboHelper(self, 'x_att',
numeric=False, datetime=False, categorical=False,
pixel_coord=True)
ProfileViewerState.function.set_choices(self, list(FUNCTIONS))
ProfileViewerState.function.set_display_func(self, FUNCTIONS.get)
self.update_from_dict(kwargs)
def _update_combo_ref_data(self):
self.ref_data_helper.set_multiple_data(self.layers_data)
def reset_limits(self):
with delay_callback(self, 'x_min', 'x_max', 'y_min', 'y_max'):
self._reset_x_limits()
self._reset_y_limits()
@property
def _display_world(self):
return getattr(self.reference_data, 'coords', None) is not None
@defer_draw
def _update_att(self, *args):
if self.x_att is not None:
if self._display_world:
if self.x_att in self.reference_data.pixel_component_ids:
self.x_att_pixel = self.x_att
else:
index = self.reference_data.world_component_ids.index(self.x_att)
self.x_att_pixel = self.reference_data.pixel_component_ids[index]
else:
self.x_att_pixel = self.x_att
self._reset_x_limits()
def _reset_x_limits(self, *event):
# NOTE: we don't use AttributeLimitsHelper because we need to avoid
# trying to get the minimum of *all* the world coordinates in the
# dataset. Instead, we use the same approach as in the layer state below
# and in the case of world coordinates we use online the spine of the
# data.
if self.reference_data is None or self.x_att_pixel is None:
return
data = self.reference_data
if self.x_att in data.pixel_component_ids:
x_min, x_max = -0.5, data.shape[self.x_att.axis] - 0.5
else:
axis = data.world_component_ids.index(self.x_att)
axis_view = [0] * data.ndim
axis_view[axis] = slice(None)
axis_values = data[self.x_att, tuple(axis_view)]
x_min, x_max = np.nanmin(axis_values), np.nanmax(axis_values)
with delay_callback(self, 'x_min', 'x_max'):
self.x_min = x_min
self.x_max = x_max
def _reset_y_limits(self, *event):
if self.normalize:
with delay_callback(self, 'y_min', 'y_max'):
self.y_min = -0.1
self.y_max = +1.1
def flip_x(self):
"""
Flip the x_min/x_max limits.
"""
with delay_callback(self, 'x_min', 'x_max'):
self.x_min, self.x_max = self.x_max, self.x_min
@defer_draw
def _layers_changed(self, *args):
self._update_combo_ref_data()
@defer_draw
def _reference_data_changed(self, *args):
for layer in self.layers:
layer.reset_cache()
# This signal can get emitted if just the choices but not the actual
# reference data change, so we check here that the reference data has
# actually changed
if self.reference_data is not getattr(self, '_last_reference_data', None):
self._last_reference_data = self.reference_data
with delay_callback(self, 'x_att'):
if self.reference_data is None:
self.x_att_helper.set_multiple_data([])
else:
self.x_att_helper.set_multiple_data([self.reference_data])
if self._display_world:
self.x_att_helper.world_coord = True
self.x_att = self.reference_data.world_component_ids[0]
else:
self.x_att_helper.world_coord = False
self.x_att = self.reference_data.pixel_component_ids[0]
self._update_att()
def _update_priority(self, name):
if name == 'layers':
return 2
elif name == 'reference_data':
return 1.5
elif name.endswith(('_min', '_max')):
return 0
else:
return 1
class ProfileLayerState(MatplotlibLayerState):
"""
A state class that includes all the attributes for layers in a Profile plot.
"""
linewidth = DDCProperty(1, docstring='The width of the line')
attribute = DDSCProperty(docstring='The attribute shown in the layer')
v_min = DDCProperty(docstring='The lower level shown')
v_max = DDCProperty(docstring='The upper level shown')
percentile = DDSCProperty(docstring='The percentile value used to '
'automatically calculate levels')
_viewer_callbacks_set = False
_profile_cache = None
def __init__(self, layer=None, viewer_state=None, **kwargs):
super(ProfileLayerState, self).__init__(layer=layer, viewer_state=viewer_state)
self.attribute_att_helper = ComponentIDComboHelper(self, 'attribute',
numeric=True, categorical=False)
percentile_display = {100: 'Min/Max',
99.5: '99.5%',
99: '99%',
95: '95%',
90: '90%',
'Custom': 'Custom'}
ProfileLayerState.percentile.set_choices(self, [100, 99.5, 99, 95, 90, 'Custom'])
ProfileLayerState.percentile.set_display_func(self, percentile_display.get)
self.add_callback('layer', self._update_attribute, priority=1000)
if layer is not None:
self._update_attribute()
self.update_from_dict(kwargs)
def _update_attribute(self, *args):
if self.layer is not None:
self.attribute_att_helper.set_multiple_data([self.layer])
@property
def independent_x_att(self):
return is_convertible_to_single_pixel_cid(self.layer, self.viewer_state.x_att) is not None
def normalize_values(self, values):
return (np.asarray(values) - self.v_min) / (self.v_max - self.v_min)
def reset_cache(self, *args):
self._profile_cache = None
@property
def viewer_state(self):
return self._viewer_state
@viewer_state.setter
def viewer_state(self, viewer_state):
self._viewer_state = viewer_state
@property
def profile(self):
self.update_profile()
return self._profile_cache
def update_profile(self, update_limits=True):
if self._profile_cache is not None:
return self._profile_cache
if not self.visible:
return
if not self._viewer_callbacks_set:
self.viewer_state.add_callback('x_att', self.reset_cache, priority=100000)
self.viewer_state.add_callback('function', self.reset_cache, priority=100000)
if self.is_callback_property('attribute'):
self.add_callback('attribute', self.reset_cache, priority=100000)
self._viewer_callbacks_set = True
if self.viewer_state is None or self.viewer_state.x_att is None or self.attribute is None:
raise IncompatibleDataException()
# Check what pixel axis in the current dataset x_att corresponds to
pix_cid = is_convertible_to_single_pixel_cid(self.layer, self.viewer_state.x_att_pixel)
if pix_cid is None:
raise IncompatibleDataException()
# If we get here, then x_att does correspond to a single pixel axis in
# the cube, so we now prepare a list of axes to collapse over.
axes = tuple(i for i in range(self.layer.ndim) if i != pix_cid.axis)
# We now get the y values for the data
# TODO: in future we should optimize the case where the mask is much
# smaller than the data to just average the relevant 'spaxels' in the
# data rather than collapsing the whole cube.
if isinstance(self.layer, Subset):
data = self.layer.data
subset_state = self.layer.subset_state
else:
data = self.layer
subset_state = None
profile_values = data.compute_statistic(self.viewer_state.function, self.attribute, axis=axes, subset_state=subset_state)
if np.all(np.isnan(profile_values)):
self._profile_cache = [], []
else:
axis_view = [0] * data.ndim
axis_view[pix_cid.axis] = slice(None)
axis_values = data[self.viewer_state.x_att, tuple(axis_view)]
self._profile_cache = axis_values, profile_values
if update_limits:
self.update_limits(update_profile=False)
def update_limits(self, update_profile=True):
with delay_callback(self, 'v_min', 'v_max'):
if update_profile:
self.update_profile(update_limits=False)
if self._profile_cache is not None and len(self._profile_cache[1]) > 0:
self.v_min = nanmin(self._profile_cache[1])
self.v_max = nanmax(self._profile_cache[1])
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/__init__.py 0000644 0001750 0001750 00000000000 13502206677 022573 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/profile/layer_artist.py 0000644 0001750 0001750 00000015174 13661230662 023555 0 ustar noahfx noahfx import sys
import warnings
import numpy as np
from matplotlib.lines import Line2D
from glue.core import BaseData
from glue.utils import defer_draw, nanmin, nanmax
from glue.viewers.profile.state import ProfileLayerState
from glue.viewers.matplotlib.layer_artist import MatplotlibLayerArtist
from glue.core.exceptions import IncompatibleAttribute, IncompatibleDataException
from glue.viewers.profile.python_export import python_export_profile_layer
class ProfileLayerArtist(MatplotlibLayerArtist):
_layer_state_cls = ProfileLayerState
_python_exporter = python_export_profile_layer
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(ProfileLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# Watch for changes in the viewer state which would require the
# layers to be redrawn
self._viewer_state.add_global_callback(self._update_profile)
self.state.add_global_callback(self._update_profile)
self.plot_artist = self.axes.plot([1, 2, 3], [3, 4, 5], 'k-', drawstyle='steps-mid')[0]
self.mpl_artists = [self.plot_artist]
@defer_draw
def _calculate_profile(self, reset=False):
try:
self.notify_start_computation()
self._calculate_profile_thread(reset=reset)
except Exception:
self._calculate_profile_error(sys.exc_info())
else:
self._calculate_profile_postthread()
def _calculate_profile_thread(self, reset=False):
# We need to ignore any warnings that happen inside the thread
# otherwise the thread tries to send these to the glue logger (which
# uses Qt), which then results in this kind of error:
# QObject::connect: Cannot queue arguments of type 'QTextCursor'
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if reset:
self.state.reset_cache()
self.state.update_profile(update_limits=False)
def _calculate_profile_postthread(self):
self.notify_end_computation()
# It's possible for this method to get called but for the state to have
# been updated in the mean time to have a histogram that raises an
# exception (for example an IncompatibleAttribute). If any errors happen
# here, we simply ignore them since _calculate_histogram_error will get
# called directly.
try:
visible_data = self.state.profile
except Exception:
return
self.enable()
# The following can happen if self.state.visible is None - in this case
# we just terminate early. If the visible property is changed, it will
# trigger the _calculate_profile code to re-run.
if visible_data is None:
return
x, y = visible_data
# Update the data values.
if len(x) > 0:
self.state.update_limits()
# Normalize profile values to the [0:1] range based on limits
if self._viewer_state.normalize:
y = self.state.normalize_values(y)
self.plot_artist.set_data(x, y)
else:
# We need to do this otherwise we get issues on Windows when
# passing an empty list to plot_artist
self.plot_artist.set_data([0.], [0.])
# TODO: the following was copy/pasted from the histogram viewer, maybe
# we can find a way to avoid duplication?
# We have to do the following to make sure that we reset the y_max as
# needed. We can't simply reset based on the maximum for this layer
# because other layers might have other values, and we also can't do:
#
# self._viewer_state.y_max = max(self._viewer_state.y_max, result[0].max())
#
# because this would never allow y_max to get smaller.
if not self._viewer_state.normalize and len(y) > 0:
y_min = nanmin(y)
y_max = nanmax(y)
y_range = y_max - y_min
self.state._y_min = y_min - y_range * 0.1
self.state._y_max = y_max + y_range * 0.1
largest_y_max = max(getattr(layer, '_y_max', 0) for layer in self._viewer_state.layers)
if largest_y_max != self._viewer_state.y_max:
self._viewer_state.y_max = largest_y_max
smallest_y_min = min(getattr(layer, '_y_min', np.inf) for layer in self._viewer_state.layers)
if smallest_y_min != self._viewer_state.y_min:
self._viewer_state.y_min = smallest_y_min
self.redraw()
@defer_draw
def _calculate_profile_error(self, exc):
self.plot_artist.set_visible(False)
self.notify_end_computation()
self.redraw()
if issubclass(exc[0], IncompatibleAttribute):
if isinstance(self.state.layer, BaseData):
self.disable_invalid_attributes(self.state.attribute)
else:
self.disable_incompatible_subset()
elif issubclass(exc[0], IncompatibleDataException):
self.disable("Incompatible data")
@defer_draw
def _update_visual_attributes(self):
if not self.enabled:
return
for mpl_artist in self.mpl_artists:
mpl_artist.set_visible(self.state.visible)
mpl_artist.set_zorder(self.state.zorder)
mpl_artist.set_color(self.state.color)
mpl_artist.set_alpha(self.state.alpha)
mpl_artist.set_linewidth(self.state.linewidth)
self.redraw()
def _update_profile(self, force=False, **kwargs):
if (self._viewer_state.x_att is None or
self.state.attribute is None or
self.state.layer is None):
return
changed = set() if force else self.pop_changed_properties()
if force or any(prop in changed for prop in ('layer', 'x_att', 'attribute', 'function', 'normalize', 'v_min', 'v_max', 'visible')):
self._calculate_profile(reset=force)
if force or any(prop in changed for prop in ('alpha', 'color', 'zorder', 'linewidth')):
self._update_visual_attributes()
@defer_draw
def update(self):
self.state.reset_cache()
self._update_profile(force=True)
self.redraw()
def get_handle_legend(self):
if self.enabled and self.state.visible:
handle = Line2D([0], [0], alpha=self.state.alpha,
linestyle="-", linewidth=self.state.linewidth,
color=self.get_layer_color())
return handle, self.layer.label, None
else:
return None, None, None
glueviz-1.0.1+dfsg.orig/glue/viewers/profile/viewer.py 0000644 0001750 0001750 00000002372 13605357235 022354 0 ustar noahfx noahfx from glue.core.subset import roi_to_subset_state
__all__ = ['MatplotlibProfileMixin']
class MatplotlibProfileMixin(object):
def setup_callbacks(self):
self.state.add_callback('x_att', self._update_axes)
self.state.add_callback('normalize', self._update_axes)
def _update_axes(self, *args):
if self.state.x_att is not None:
self.state.x_axislabel = self.state.x_att.label
if self.state.normalize:
self.state.y_axislabel = 'Normalized data values'
else:
self.state.y_axislabel = 'Data values'
self.axes.figure.canvas.draw_idle()
def apply_roi(self, roi, override_mode=None):
# Force redraw to get rid of ROI. We do this because applying the
# subset state below might end up not having an effect on the viewer,
# for example there may not be any layers, or the active subset may not
# be one of the layers. So we just explicitly redraw here to make sure
# a redraw will happen after this method is called.
self.redraw()
if len(self.layers) == 0:
return
subset_state = roi_to_subset_state(roi, x_att=self.state.x_att)
self.apply_subset_state(subset_state, override_mode=override_mode)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/ 0000755 0001750 0001750 00000000000 13752535025 021030 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/tests/ 0000755 0001750 0001750 00000000000 13752535025 022172 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024276 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/tests/test_layer_artist.py 0000644 0001750 0001750 00000006671 13662766630 026327 0 ustar noahfx noahfx from collections import Counter
import sys
from glue.core import Data, DataCollection
from ..layer_artist import HistogramLayerArtist
from ..state import HistogramViewerState
from matplotlib import pyplot as plt
class CallCounter(object):
def __init__(self):
self._counter = Counter()
def __call__(self, frame, event, arg):
if event == 'call':
self._counter[frame.f_code.co_name] += 1
def __getitem__(self, item):
return self._counter[item]
class TestHistogramLayerArtist(object):
def setup_method(self, method):
self.viewer_state = HistogramViewerState()
ax = plt.subplot(1, 1, 1)
self.data = Data(x=[1, 2, 3], y=[2, 3, 4])
self.subset = self.data.new_subset()
self.subset.subset_state = self.data.id['x'] > 1
dc = DataCollection([self.data])
# TODO: The following line shouldn't be needed
self.viewer_state.data_collection = dc
self.artist = HistogramLayerArtist(ax, self.viewer_state, layer=self.subset)
self.layer_state = self.artist.state
self.viewer_state.layers.append(self.layer_state)
self.call_counter = CallCounter()
sys.setprofile(self.call_counter)
def teardown_method(self, method):
self.artist.remove()
sys.setprofile(None)
def test_recalc_on_state_changes(self):
assert self.call_counter['_calculate_histogram'] == 0
assert self.call_counter['_update_artists'] == 0
# attribute
self.viewer_state.x_att = self.data.id['y']
assert self.call_counter['_calculate_histogram'] == 1
assert self.call_counter['_update_artists'] == 1
# lo
self.viewer_state.hist_x_min = -1
assert self.call_counter['_calculate_histogram'] == 2
assert self.call_counter['_update_artists'] == 2
# hi
self.viewer_state.hist_x_max = 5
assert self.call_counter['_calculate_histogram'] == 3
assert self.call_counter['_update_artists'] == 3
# nbins
self.viewer_state.hist_n_bin += 1
assert self.call_counter['_calculate_histogram'] == 4
assert self.call_counter['_update_artists'] == 4
# xlog
self.viewer_state.x_log ^= True
assert self.call_counter['_calculate_histogram'] == 5
assert self.call_counter['_update_artists'] == 5
# TODO: find a way to determine whether the histogram calculation is
# carried out since _calculate_histogram calls are no longer a good
# way to find out (we now rely on state cache)
# ylog -- no call
self.viewer_state.y_log ^= True
# assert self.call_counter['_calculate_histogram'] == 5
assert self.call_counter['_update_artists'] == 6
# cumulative -- no call
self.viewer_state.cumulative ^= True
# assert self.call_counter['_calculate_histogram'] == 5
assert self.call_counter['_update_artists'] == 7
# normed -- no call
self.viewer_state.normalize ^= True
# assert self.call_counter['_calculate_histogram'] == 5
assert self.call_counter['_update_artists'] == 8
# subset style -- no call
self.subset.style.color = '#00ff00'
# assert self.call_counter['_calculate_histogram'] == 5
assert self.call_counter['_update_artists'] == 8
# legend -- no call
self.viewer_state.show_legend = True
assert self.call_counter['_update_artists'] == 8
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/ 0000755 0001750 0001750 00000000000 13752535025 021454 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022616 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/test_python_export.py 0000644 0001750 0001750 00000004311 13752534424 027152 0 ustar noahfx noahfx from astropy.utils import NumpyRNGContext
from glue.core import Data, DataCollection
from glue.app.qt.application import GlueApplication
from glue.viewers.histogram.qt import HistogramViewer
from glue.viewers.matplotlib.qt.tests.test_python_export import BaseTestExportPython, random_with_nan
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)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024722 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/data/ 0000755 0001750 0001750 00000000000 13752535025 023527 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/data/histogram_v0.glu 0000644 0001750 0001750 00000021172 13502206677 026646 0 ustar noahfx noahfx {
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAA=="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgIAoAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAGAAAAAAAAAAgAAAAAAAAACgAAAAAAAAAMAAAAAAAAAA4AAAAAAAAAEAAAAAAAAAASAAAAAAAAAA=="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0"
],
"data": [
"data"
],
"groups": [
"Subset 1_0"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0"
],
"subset_group_count": 1
},
"HistogramWidget": {
"_type": "glue.viewers.histogram.qt.viewer_widget.HistogramWidget",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 9,
"layer": "data",
"lo": 0,
"nbins": 6.0,
"visible": true,
"xlog": false,
"zorder": 1
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 9,
"layer": "Subset 1",
"lo": 0,
"nbins": 6.0,
"visible": false,
"xlog": false,
"zorder": 2
}
],
"pos": [
0,
0
],
"properties": {
"autoscale": true,
"component": "a",
"cumulative": false,
"nbins": 6.0,
"normed": false,
"xlog": false,
"xmax": 9.0,
"xmin": 0.0,
"ylog": false
},
"session": "Session",
"size": [
600,
400
]
},
"HistogramWidget_0": {
"_type": "glue.viewers.histogram.qt.viewer_widget.HistogramWidget",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 16.0,
"layer": "data",
"lo": 2.0,
"nbins": 8.0,
"visible": true,
"xlog": false,
"zorder": 1
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 16.0,
"layer": "Subset 1",
"lo": 2.0,
"nbins": 8.0,
"visible": true,
"xlog": false,
"zorder": 2
}
],
"pos": [
502,
362
],
"properties": {
"autoscale": true,
"component": "b",
"cumulative": false,
"nbins": 8.0,
"normed": false,
"xlog": false,
"xmax": 16.0,
"xmin": 2.0,
"ylog": false
},
"session": "Session",
"size": [
600,
400
]
},
"HistogramWidget_1": {
"_type": "glue.viewers.histogram.qt.viewer_widget.HistogramWidget",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 9,
"layer": "data",
"lo": 0,
"nbins": 10.0,
"visible": true,
"xlog": false,
"zorder": 1
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 9,
"layer": "Subset 1",
"lo": 0,
"nbins": 10.0,
"visible": true,
"xlog": false,
"zorder": 2
}
],
"pos": [
502,
0
],
"properties": {
"autoscale": true,
"component": "a",
"cumulative": false,
"nbins": 10.0,
"normed": true,
"xlog": false,
"xmax": 9.0,
"xmin": 0.0,
"ylog": true
},
"session": "Session",
"size": [
600,
400
]
},
"HistogramWidget_2": {
"_type": "glue.viewers.histogram.qt.viewer_widget.HistogramWidget",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 10.0,
"layer": "data",
"lo": -1.0,
"nbins": 4.0,
"visible": true,
"xlog": false,
"zorder": 1
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"hi": 10.0,
"layer": "Subset 1",
"lo": -1.0,
"nbins": 4.0,
"visible": true,
"xlog": false,
"zorder": 2
}
],
"pos": [
0,
362
],
"properties": {
"autoscale": true,
"component": "a",
"cumulative": true,
"nbins": 4.0,
"normed": false,
"xlog": false,
"xmax": 10.0,
"xmin": -1.0,
"ylog": false
},
"session": "Session",
"size": [
600,
400
]
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"RangeSubsetState": {
"_type": "glue.core.subset.RangeSubsetState",
"att": "a",
"hi": 4.5,
"lo": 1.5
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1_0",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"Subset 1_0": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RangeSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1"
]
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue_vispy_viewers.scatter",
"glue.plugins.tools.spectrum_tool",
"glue.viewers.table",
"glue.viewers.histogram",
"glue.viewers.scatter",
"glue.viewers.image",
"glue.plugins.tools.pv_slicer",
"glue.plugins.coordinate_helpers",
"glue.plugins.exporters.plotly",
"glue.plugins.export_d3po",
"glue.core.data_exporters",
"glue_h5part",
"glue_vispy_viewers.volume"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"HistogramWidget",
"HistogramWidget_0",
"HistogramWidget_1",
"HistogramWidget_2"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"data": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "data",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1"
],
"uuid": "103f82ee-7731-4816-b207-164b683762d2"
}
} glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/data/histogram_v1.glu 0000644 0001750 0001750 00000027147 13644362032 026652 0 ustar noahfx noahfx {
"CallbackList": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"HistogramLayerState",
"HistogramLayerState_0"
]
},
"CallbackList_0": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"HistogramLayerState_1",
"HistogramLayerState_2"
]
},
"CallbackList_1": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"HistogramLayerState_3",
"HistogramLayerState_4"
]
},
"CallbackList_2": {
"_type": "glue.external.echo.list.CallbackList",
"values": [
"HistogramLayerState_5",
"HistogramLayerState_6"
]
},
"Component": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgIAoAAAAAAAAAAAEAAAAAAAAAAgAAAAAAAAADAAAAAAAAAAQAAAAAAAAABQAAAAAAAAAGAAAAAAAAAAcAAAAAAAAACAAAAAAAAAAJAAAAAAAAAA=="
},
"units": ""
},
"Component_0": {
"_type": "glue.core.component.Component",
"data": {
"_type": "numpy.ndarray",
"data": "k05VTVBZAQBGAHsnZGVzY3InOiAnPGk4JywgJ2ZvcnRyYW5fb3JkZXInOiBGYWxzZSwgJ3NoYXBlJzogKDEwLCksIH0gICAgICAgICAgIAoAAAAAAAAAAAIAAAAAAAAABAAAAAAAAAAGAAAAAAAAAAgAAAAAAAAACgAAAAAAAAAMAAAAAAAAAA4AAAAAAAAAEAAAAAAAAAASAAAAAAAAAA=="
},
"units": ""
},
"CoordinateComponent": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": false
},
"CoordinateComponentLink": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponentLink_0": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_1": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"World 0"
],
"index": 0,
"pix2world": false,
"to": [
"Pixel Axis 0 [x]"
]
},
"CoordinateComponentLink_2": {
"_type": "glue.core.component_link.CoordinateComponentLink",
"coords": "Coordinates",
"frm": [
"Pixel Axis 0 [x]"
],
"index": 0,
"pix2world": true,
"to": [
"World 0"
]
},
"CoordinateComponent_0": {
"_type": "glue.core.component.CoordinateComponent",
"axis": 0,
"world": true
},
"Coordinates": {
"_type": "glue.core.coordinates.Coordinates"
},
"DataCollection": {
"_protocol": 3,
"_type": "glue.core.data_collection.DataCollection",
"cids": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"components": [
"Component",
"CoordinateComponent",
"CoordinateComponent_0",
"Component_0"
],
"data": [
"data"
],
"groups": [
"Subset 1"
],
"links": [
"CoordinateComponentLink",
"CoordinateComponentLink_0",
"CoordinateComponentLink_1",
"CoordinateComponentLink_2"
],
"subset_group_count": 1
},
"HistogramLayerState": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "data",
"visible": true,
"zorder": 2
}
},
"HistogramLayerState_0": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": false,
"zorder": 3
}
},
"HistogramLayerState_1": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "data",
"visible": true,
"zorder": 2
}
},
"HistogramLayerState_2": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": true,
"zorder": 3
}
},
"HistogramLayerState_3": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "data",
"visible": true,
"zorder": 2
}
},
"HistogramLayerState_4": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": true,
"zorder": 3
}
},
"HistogramLayerState_5": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.8,
"color": "st__0.35",
"layer": "data",
"visible": true,
"zorder": 2
}
},
"HistogramLayerState_6": {
"_type": "glue.viewers.histogram.state.HistogramLayerState",
"values": {
"alpha": 0.5,
"color": "st__#e31a1c",
"layer": "Subset 1_0",
"visible": true,
"zorder": 3
}
},
"HistogramViewer": {
"_protocol": 1,
"_type": "glue.viewers.histogram.qt.data_viewer.HistogramViewer",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState"
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_0"
}
],
"pos": [
664,
475
],
"session": "Session",
"size": [
663,
473
],
"state": {
"values": {
"common_n_bin": true,
"cumulative": false,
"hist_n_bin": 6,
"hist_x_max": 9.0,
"hist_x_min": 0.0,
"layers": "CallbackList",
"normalize": false,
"x_att": "a",
"x_log": false,
"x_max": 9.0,
"x_min": 0.0,
"y_log": false,
"y_max": 2.4,
"y_min": 0
}
}
},
"HistogramViewer_0": {
"_protocol": 1,
"_type": "glue.viewers.histogram.qt.data_viewer.HistogramViewer",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_1"
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_2"
}
],
"pos": [
0,
475
],
"session": "Session",
"size": [
664,
473
],
"state": {
"values": {
"common_n_bin": true,
"cumulative": false,
"hist_n_bin": 8,
"hist_x_max": 16.0,
"hist_x_min": 2.0,
"layers": "CallbackList_0",
"normalize": false,
"x_att": "b",
"x_log": false,
"x_max": 16.0,
"x_min": 2.0,
"y_log": false,
"y_max": 1.2,
"y_min": 0
}
}
},
"HistogramViewer_1": {
"_protocol": 1,
"_type": "glue.viewers.histogram.qt.data_viewer.HistogramViewer",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_3"
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_4"
}
],
"pos": [
664,
0
],
"session": "Session",
"size": [
663,
475
],
"state": {
"values": {
"common_n_bin": true,
"cumulative": false,
"hist_n_bin": 10,
"hist_x_max": 9.0,
"hist_x_min": 0.0,
"layers": "CallbackList_1",
"normalize": true,
"x_att": "a",
"x_log": false,
"x_max": 9.0,
"x_min": 0.0,
"y_log": true,
"y_max": 0.7407407407407407,
"y_min": 0.01111111111111111
}
}
},
"HistogramViewer_2": {
"_protocol": 1,
"_type": "glue.viewers.histogram.qt.data_viewer.HistogramViewer",
"layers": [
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_5"
},
{
"_type": "glue.viewers.histogram.layer_artist.HistogramLayerArtist",
"state": "HistogramLayerState_6"
}
],
"pos": [
0,
0
],
"session": "Session",
"size": [
664,
475
],
"state": {
"values": {
"common_n_bin": true,
"cumulative": true,
"hist_n_bin": 4,
"hist_x_max": 10.0,
"hist_x_min": -1.0,
"layers": "CallbackList_2",
"normalize": false,
"x_att": "a",
"x_log": false,
"x_max": 10.0,
"x_min": -1.0,
"y_log": false,
"y_max": 12.0,
"y_min": 0
}
}
},
"Pixel Axis 0 [x]": {
"_type": "glue.core.component_id.PixelComponentID",
"axis": 0,
"hidden": true,
"label": "Pixel Axis 0 [x]"
},
"RangeSubsetState": {
"_type": "glue.core.subset.RangeSubsetState",
"att": "a",
"hi": 4.5,
"lo": 1.5
},
"Session": {
"_type": "glue.core.session.Session"
},
"Subset 1": {
"_type": "glue.core.subset_group.SubsetGroup",
"label": "Subset 1",
"state": "RangeSubsetState",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
},
"subsets": [
"Subset 1_0"
]
},
"Subset 1_0": {
"_type": "glue.core.subset_group.GroupedSubset",
"group": "Subset 1",
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.5,
"color": "#e31a1c",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 7
}
},
"World 0": {
"_type": "glue.core.component_id.ComponentID",
"hidden": true,
"label": "World 0"
},
"__main__": {
"_type": "glue.app.qt.application.GlueApplication",
"data": "DataCollection",
"plugins": [
"glue_vispy_viewers.scatter",
"glue.plugins.coordinate_helpers",
"glue.plugins.exporters.plotly",
"glue.viewers.table",
"glue.core.data_exporters",
"glue_medical",
"glue.plugins.tools.pv_slicer",
"specviz.app",
"glue.viewers.scatter",
"glue.viewers.histogram",
"glue_vispy_viewers.volume",
"glue.plugins.tools.spectrum_tool",
"glue.plugins.export_d3po",
"glue.viewers.image"
],
"session": "Session",
"tab_names": [
"Tab 1"
],
"viewers": [
[
"HistogramViewer",
"HistogramViewer_0",
"HistogramViewer_1",
"HistogramViewer_2"
]
]
},
"a": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "a"
},
"b": {
"_type": "glue.core.component_id.ComponentID",
"hidden": false,
"label": "b"
},
"data": {
"_key_joins": [],
"_protocol": 5,
"_type": "glue.core.data.Data",
"components": [
[
"a",
"Component"
],
[
"Pixel Axis 0 [x]",
"CoordinateComponent"
],
[
"World 0",
"CoordinateComponent_0"
],
[
"b",
"Component_0"
]
],
"coords": "Coordinates",
"label": "data",
"primary_owner": [
"a",
"Pixel Axis 0 [x]",
"World 0",
"b"
],
"style": {
"_type": "glue.core.visual.VisualAttributes",
"alpha": 0.8,
"color": "0.35",
"linestyle": "solid",
"linewidth": 1,
"marker": "o",
"markersize": 3
},
"subsets": [
"Subset 1_0"
],
"uuid": "103f82ee-7731-4816-b207-164b683762d2"
}
}
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/tests/test_data_viewer.py 0000644 0001750 0001750 00000063404 13752534424 026532 0 ustar noahfx noahfx # pylint: disable=I0011,W0613,W0201,W0212,E1101,E1103
import os
from collections import Counter
import pytest
import numpy as np
from numpy.testing import assert_equal, assert_allclose
from glue.core.message import SubsetUpdateMessage
from glue.core import HubListener, Data
from glue.core.roi import XRangeROI, RectangularROI
from glue.core.subset import RangeSubsetState, CategoricalROISubsetState, RoiSubsetState
from glue import core
from glue.app.qt import GlueApplication
from glue.core.component_id import ComponentID
from glue.utils.qt import combo_as_string, process_events
from glue.viewers.matplotlib.qt.tests.test_data_viewer import BaseTestMatplotlibDataViewer
from glue.core.state import GlueUnSerializer
from glue.app.qt.layer_tree_widget import LayerTreeWidget
from glue.tests.helpers import requires_matplotlib_ge_22
from ..data_viewer import HistogramViewer
DATA = os.path.join(os.path.dirname(__file__), 'data')
class TestHistogramCommon(BaseTestMatplotlibDataViewer):
def init_data(self):
return Data(label='d1', x=[3.4, 2.3, -1.1, 0.3], y=['a', 'b', 'c', 'a'])
viewer_cls = HistogramViewer
class TestHistogramViewer(object):
def setup_method(self, method):
self.data = Data(label='d1', x=[3.4, 2.3, -1.1, 0.3], y=['a', 'b', 'c', 'a'])
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(HistogramViewer)
def teardown_method(self, method):
self.viewer.close()
self.viewer = None
self.app.close()
self.app = None
def test_basic(self):
viewer_state = self.viewer.state
# Check defaults when we add data
self.viewer.add_data(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:Coordinate components:Pixel Axis 0 [x]'
assert viewer_state.x_att is self.data.id['x']
assert viewer_state.x_min == -1.1
assert viewer_state.x_max == 3.4
assert viewer_state.y_min == 0.0
assert viewer_state.y_max == 1.2
assert viewer_state.hist_x_min == -1.1
assert viewer_state.hist_x_max == 3.4
assert viewer_state.hist_n_bin == 15
assert not viewer_state.cumulative
assert not viewer_state.normalize
assert not viewer_state.x_log
assert not viewer_state.y_log
assert len(viewer_state.layers) == 1
# Change to categorical component and check new values
viewer_state.x_att = self.data.id['y']
assert viewer_state.x_min == -0.5
assert viewer_state.x_max == 2.5
assert viewer_state.y_min == 0.0
assert viewer_state.y_max == 2.4
assert viewer_state.hist_x_min == -0.5
assert viewer_state.hist_x_max == 2.5
assert viewer_state.hist_n_bin == 3
assert not viewer_state.cumulative
assert not viewer_state.normalize
assert not viewer_state.x_log
assert not viewer_state.y_log
def test_log_labels(self):
# Regression test to make sure the labels are correctly changed to log
# when the x-axis is in log space.
viewer_state = self.viewer.state
data = Data(x=np.logspace(-5, 5, 10000))
self.data_collection.append(data)
self.viewer.add_data(data)
viewer_state.x_log = True
process_events()
labels = [x.get_text() for x in self.viewer.axes.xaxis.get_ticklabels()]
# Different Matplotlib versions return slightly different
# labels, but the ones below should be present regardless
# of Matplotlib version.
expected_present = ['$\\mathdefault{10^{-5}}$',
'$\\mathdefault{10^{-3}}$',
'$\\mathdefault{10^{-1}}$',
'$\\mathdefault{10^{1}}$',
'$\\mathdefault{10^{3}}$',
'$\\mathdefault{10^{5}}$']
for label in expected_present:
assert label in labels
def test_flip(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
assert viewer_state.x_min == -1.1
assert viewer_state.x_max == 3.4
self.viewer.options_widget().button_flip_x.click()
assert viewer_state.x_min == 3.4
assert viewer_state.x_max == -1.1
def test_remove_data(self):
self.viewer.add_data(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:Coordinate components:Pixel Axis 0 [x]'
self.data_collection.remove(self.data)
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == ''
def test_update_component_updates_title(self):
self.viewer.add_data(self.data)
assert self.viewer.windowTitle() == '1D Histogram'
self.viewer.state.x_att = self.data.id['y']
assert self.viewer.windowTitle() == '1D Histogram'
def test_combo_updates_with_component_add(self):
self.viewer.add_data(self.data)
self.data.add_component([3, 4, 1, 2], 'z')
assert self.viewer.state.x_att is self.data.id['x']
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:x:y:z:Coordinate components:Pixel Axis 0 [x]'
def test_nonnumeric_first_component(self):
# regression test for #208. Shouldn't complain if
# first component is non-numerical
data = core.Data()
data.add_component(['a', 'b', 'c'], label='c1')
data.add_component([1, 2, 3], label='c2')
self.data_collection.append(data)
self.viewer.add_data(data)
def test_nan_component(self):
# regression test for case when all values are NaN in a component
data = core.Data()
data.add_component([np.nan, np.nan, np.nan], label='c1')
self.data_collection.append(data)
self.viewer.add_data(data)
def test_histogram_values(self):
# Check the actual values of the histograms
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
# Numerical attribute
viewer_state.hist_x_min = -5
viewer_state.hist_x_max = 5
viewer_state.hist_n_bin = 4
assert_allclose(self.viewer.state.y_max, 2.4)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 1, 2, 1])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
cid = self.data.main_components[0]
self.data_collection.new_subset_group('subset 1', cid < 2)
assert_allclose(self.viewer.layers[1].state.histogram[1], [0, 1, 1, 0])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
viewer_state.normalize = True
assert_allclose(self.viewer.state.y_max, 0.24)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0.1, 0.2, 0.1])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0, 0.2, 0.2, 0])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
viewer_state.cumulative = True
assert_allclose(self.viewer.state.y_max, 1.2)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0.25, 0.75, 1.0])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0, 0.5, 1.0, 1.0])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
viewer_state.normalize = False
assert_allclose(self.viewer.state.y_max, 4.8)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 1, 3, 4])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0, 1, 2, 2])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-5, -2.5, 0, 2.5, 5])
viewer_state.cumulative = False
# Categorical attribute
viewer_state.x_att = self.data.id['y']
formatter = self.viewer.axes.xaxis.get_major_formatter()
xlabels = [formatter.format_data(pos) for pos in range(3)]
assert xlabels == ['a', 'b', 'c']
assert_allclose(self.viewer.state.y_max, 2.4)
assert_allclose(self.viewer.layers[0].state.histogram[1], [2, 1, 1])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [1, 0, 1])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
viewer_state.normalize = True
assert_allclose(self.viewer.state.y_max, 0.6)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0.5, 0.25, 0.25])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0.5, 0, 0.5])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
viewer_state.cumulative = True
assert_allclose(self.viewer.state.y_max, 1.2)
assert_allclose(self.viewer.layers[0].state.histogram[1], [0.5, 0.75, 1])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0.5, 0.5, 1])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
viewer_state.normalize = False
assert_allclose(self.viewer.state.y_max, 4.8)
assert_allclose(self.viewer.layers[0].state.histogram[1], [2, 3, 4])
assert_allclose(self.viewer.layers[0].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
assert_allclose(self.viewer.layers[1].state.histogram[1], [1, 1, 2])
assert_allclose(self.viewer.layers[1].state.histogram[0], [-0.5, 0.5, 1.5, 2.5])
# TODO: add tests for log
def test_apply_roi(self):
# Check that when doing an ROI selection, the ROI clips to the bin edges
# outside the selection
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
viewer_state.hist_x_min = -5
viewer_state.hist_x_max = 5
viewer_state.hist_n_bin = 4
roi = XRangeROI(-0.2, 0.1)
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 1, 2, 1])
assert_allclose(self.viewer.layers[1].state.histogram[1], [0, 1, 2, 0])
assert_allclose(self.data.subsets[0].to_mask(), [0, 1, 1, 1])
state = self.data.subsets[0].subset_state
assert isinstance(state, RangeSubsetState)
assert state.lo == -2.5
assert state.hi == 2.5
# TODO: add a similar test in log space
def test_apply_roi_categorical(self):
# Check that when doing an ROI selection, the ROI clips to the bin edges
# outside the selection
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
viewer_state.x_att = self.data.id['y']
roi = XRangeROI(0.3, 0.9)
assert len(self.viewer.layers) == 1
self.viewer.apply_roi(roi)
assert len(self.viewer.layers) == 2
assert_allclose(self.viewer.layers[0].state.histogram[1], [2, 1, 1])
assert_allclose(self.viewer.layers[1].state.histogram[1], [2, 1, 0])
assert_allclose(self.data.subsets[0].to_mask(), [1, 1, 0, 1])
state = self.data.subsets[0].subset_state
assert isinstance(state, CategoricalROISubsetState)
assert_equal(state.roi.categories, ['a', 'b'])
def test_apply_roi_empty(self):
# Make sure that doing an ROI selection on an empty viewer doesn't
# produce error messsages
roi = XRangeROI(-0.2, 0.1)
self.viewer.apply_roi(roi)
def test_axes_labels(self):
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
assert self.viewer.axes.get_xlabel() == 'x'
assert self.viewer.axes.get_ylabel() == 'Number'
viewer_state.x_log = True
assert self.viewer.axes.get_xlabel() == 'Log x'
assert self.viewer.axes.get_ylabel() == 'Number'
viewer_state.x_att = self.data.id['y']
assert self.viewer.axes.get_xlabel() == 'y'
assert self.viewer.axes.get_ylabel() == 'Number'
viewer_state.normalize = True
assert self.viewer.axes.get_xlabel() == 'y'
assert self.viewer.axes.get_ylabel() == 'Normalized number'
viewer_state.normalize = False
viewer_state.cumulative = True
assert self.viewer.axes.get_xlabel() == 'y'
assert self.viewer.axes.get_ylabel() == 'Number'
def test_y_min_y_max(self):
# Regression test for a bug that caused y_max to not be set correctly
# when multiple subsets were present and after turning on normalization
# after switching to a different attribute from that used to make the
# selection.
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
self.data.add_component([3.4, 3.5, 10.2, 20.3], 'z')
viewer_state.x_att = self.data.id['x']
cid = self.data.main_components[0]
self.data_collection.new_subset_group('subset 1', cid < 1)
cid = self.data.main_components[0]
self.data_collection.new_subset_group('subset 2', cid < 2)
cid = self.data.main_components[0]
self.data_collection.new_subset_group('subset 3', cid < 3)
assert_allclose(self.viewer.state.y_min, 0)
assert_allclose(self.viewer.state.y_max, 1.2)
viewer_state.x_att = self.data.id['z']
assert_allclose(self.viewer.state.y_min, 0)
assert_allclose(self.viewer.state.y_max, 2.4)
viewer_state.normalize = True
assert_allclose(self.viewer.state.y_min, 0)
assert_allclose(self.viewer.state.y_max, 0.5325443786982249)
def test_update_when_limits_unchanged(self):
# Regression test for glue-viz/glue#1010 - this bug caused histograms
# to not be recomputed if the attribute changed but the limits and
# number of bins did not.
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
viewer_state.x_att = self.data.id['y']
viewer_state.hist_x_min = -10.1
viewer_state.hist_x_max = +10
viewer_state.hist_n_bin = 5
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0, 3, 1, 0])
viewer_state.x_att = self.data.id['x']
viewer_state.hist_x_min = -10.1
viewer_state.hist_x_max = +10
viewer_state.hist_n_bin = 5
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0, 2, 2, 0])
viewer_state.x_att = self.data.id['y']
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0, 3, 1, 0])
viewer_state.x_att = self.data.id['x']
assert_allclose(self.viewer.layers[0].state.histogram[1], [0, 0, 2, 2, 0])
def test_component_replaced(self):
# regression test for 508 - if a component ID is replaced, we should
# make sure that the component ID is selected if the old component ID
# was selected
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['x']
test = ComponentID('test')
self.data.update_id(self.viewer.state.x_att, test)
assert self.viewer.state.x_att is test
assert combo_as_string(self.viewer.options_widget().ui.combosel_x_att) == 'Main components:test:y:Coordinate components:Pixel Axis 0 [x]'
def test_nbin_override_persists_over_numerical_attribute_change(self):
# regression test for #398
self.data.add_component([3, 4, 1, 2], 'z')
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['x']
self.viewer.state.hist_n_bin = 7
self.viewer.state.x_att = self.data.id['z']
assert self.viewer.state.hist_n_bin == 7
@pytest.mark.parametrize('protocol', [0, 1])
def test_session_back_compat(self, protocol):
filename = os.path.join(DATA, 'histogram_v{0}.glu'.format(protocol))
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
dc = ga.session.data_collection
assert len(dc) == 1
assert dc[0].label == 'data'
viewer1 = ga.viewers[0][0]
assert len(viewer1.state.layers) == 2
assert viewer1.state.x_att is dc[0].id['a']
assert_allclose(viewer1.state.x_min, 0)
assert_allclose(viewer1.state.x_max, 9)
assert_allclose(viewer1.state.y_min, 0)
assert_allclose(viewer1.state.y_max, 2.4)
assert_allclose(viewer1.state.hist_x_min, 0)
assert_allclose(viewer1.state.hist_x_max, 9)
assert_allclose(viewer1.state.hist_n_bin, 6)
assert not viewer1.state.x_log
assert not viewer1.state.y_log
assert viewer1.state.layers[0].visible
assert not viewer1.state.layers[1].visible
assert not viewer1.state.cumulative
assert not viewer1.state.normalize
viewer2 = ga.viewers[0][1]
assert viewer2.state.x_att is dc[0].id['b']
assert_allclose(viewer2.state.x_min, 2)
assert_allclose(viewer2.state.x_max, 16)
assert_allclose(viewer2.state.y_min, 0)
assert_allclose(viewer2.state.y_max, 1.2)
assert_allclose(viewer2.state.hist_x_min, 2)
assert_allclose(viewer2.state.hist_x_max, 16)
assert_allclose(viewer2.state.hist_n_bin, 8)
assert not viewer2.state.x_log
assert not viewer2.state.y_log
assert viewer2.state.layers[0].visible
assert viewer2.state.layers[1].visible
assert not viewer2.state.cumulative
assert not viewer2.state.normalize
viewer3 = ga.viewers[0][2]
assert viewer3.state.x_att is dc[0].id['a']
assert_allclose(viewer3.state.x_min, 0)
assert_allclose(viewer3.state.x_max, 9)
assert_allclose(viewer3.state.y_min, 0.01111111111111111)
assert_allclose(viewer3.state.y_max, 0.7407407407407407)
assert_allclose(viewer3.state.hist_x_min, 0)
assert_allclose(viewer3.state.hist_x_max, 9)
assert_allclose(viewer3.state.hist_n_bin, 10)
assert not viewer3.state.x_log
assert viewer3.state.y_log
assert viewer3.state.layers[0].visible
assert viewer3.state.layers[1].visible
assert not viewer3.state.cumulative
assert viewer3.state.normalize
viewer4 = ga.viewers[0][3]
assert viewer4.state.x_att is dc[0].id['a']
assert_allclose(viewer4.state.x_min, -1)
assert_allclose(viewer4.state.x_max, 10)
assert_allclose(viewer4.state.y_min, 0)
assert_allclose(viewer4.state.y_max, 12)
assert_allclose(viewer4.state.hist_x_min, -1)
assert_allclose(viewer4.state.hist_x_max, 10)
assert_allclose(viewer4.state.hist_n_bin, 4)
assert not viewer4.state.x_log
assert not viewer4.state.y_log
assert viewer4.state.layers[0].visible
assert viewer4.state.layers[1].visible
assert viewer4.state.cumulative
assert not viewer4.state.normalize
ga.close()
def test_apply_roi_single(self):
# Regression test for a bug that caused mode.update to be called
# multiple times and resulted in all other viewers receiving many
# messages regarding subset updates (this occurred when multiple)
# datasets were present.
layer_tree = LayerTreeWidget(session=self.session)
layer_tree.set_checkable(False)
layer_tree.setup(self.data_collection)
layer_tree.bind_selection_to_edit_subset()
class Client(HubListener):
def __init__(self, *args, **kwargs):
super(Client, self).__init__(*args, **kwargs)
self.count = Counter()
def ping(self, message):
self.count[message.sender] += 1
def register_to_hub(self, hub):
hub.subscribe(self, SubsetUpdateMessage, handler=self.ping)
d1 = Data(a=[1, 2, 3], label='d1')
d2 = Data(b=[1, 2, 3], label='d2')
d3 = Data(c=[1, 2, 3], label='d3')
d4 = Data(d=[1, 2, 3], label='d4')
self.data_collection.append(d1)
self.data_collection.append(d2)
self.data_collection.append(d3)
self.data_collection.append(d4)
client = Client()
client.register_to_hub(self.hub)
self.viewer.add_data(d1)
self.viewer.add_data(d3)
roi = XRangeROI(2.5, 3.5)
self.viewer.apply_roi(roi)
for subset in client.count:
assert client.count[subset] == 1
@pytest.mark.filterwarnings('ignore:elementwise')
def test_datetime64_support(self, tmpdir):
self.data.add_component(np.array([100, 200, 300, 400], dtype='M8[D]'), 't1')
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['t1']
# Matplotlib deals with dates by converting them to the number of days
# since 01-01-0001, so we can check that the limits are correctly
# converted (and not 100 to 400)
assert self.viewer.axes.get_xlim() == (719263.0, 719563.0)
# Apply an ROI selection in plotting coordinates
roi = XRangeROI(719313, 719513)
self.viewer.apply_roi(roi)
# Check that the two middle elements are selected
assert_equal(self.data.subsets[0].to_mask(), [0, 1, 1, 0])
# Make sure that the Qt labels look ok
options = self.viewer.options_widget().ui
assert options.valuetext_x_min.text() == '1970-04-11'
assert options.valuetext_x_max.text() == '1971-02-05'
# Make sure that we can set the xmin/xmax to a string date
assert_equal(self.viewer.state.x_min, np.datetime64('1970-04-11', 'D'))
options.valuetext_x_min.setText('1970-04-14')
options.valuetext_x_min.editingFinished.emit()
assert self.viewer.axes.get_xlim() == (719266.0, 719563.0)
assert_equal(self.viewer.state.x_min, np.datetime64('1970-04-14', 'D'))
# Make sure that everything works fine after saving/reloading
filename = tmpdir.join('test_datetime64.glu').strpath
self.session.application.save_session(filename)
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
viewer = ga.viewers[0][0]
options = viewer.options_widget().ui
assert_equal(self.viewer.state.x_min, np.datetime64('1970-04-14', 'D'))
assert options.valuetext_x_min.text() == '1970-04-14'
assert options.valuetext_x_max.text() == '1971-02-05'
ga.close()
@requires_matplotlib_ge_22
def test_categorical_labels(self, tmpdir):
# Fix a bug that caused labels on histograms of categorical variables
# to not be restored correctly after saving and reloading session
self.viewer.add_data(self.data)
self.viewer.state.x_att = self.data.id['y']
self.viewer.figure.canvas.draw()
assert [x.get_text() for x in self.viewer.axes.xaxis.get_ticklabels()] == ['', 'a', 'b', 'c', '']
# Make sure that everything works fine after saving/reloading
filename = tmpdir.join('test_categorical_labels.glu').strpath
self.session.application.save_session(filename)
with open(filename, 'r') as f:
session = f.read()
state = GlueUnSerializer.loads(session)
ga = state.object('__main__')
viewer = ga.viewers[0][0]
viewer.figure.canvas.draw()
assert [x.get_text() for x in viewer.axes.xaxis.get_ticklabels()] == ['', 'a', 'b', 'c', '']
ga.close()
def test_legend(self):
from matplotlib.colors import to_hex
viewer_state = self.viewer.state
self.viewer.add_data(self.data)
self.viewer.state.legend.visible = True
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 1
assert labels[0] == 'd1'
self.data_collection.new_subset_group('test', self.data.id['x'] > 1)
assert len(viewer_state.layers) == 2
handles, labels, handler_dict = self.viewer.get_handles_legend()
assert len(handles) == 2
assert labels[1] == 'test'
assert to_hex(handles[1].get_facecolor()) == viewer_state.layers[1].color
def test_with_dask_array():
# Regression test for a bug that caused the histogram to now work when
# making spatial selections on a cube represented as a dask array
da = pytest.importorskip('dask.array')
data = Data(x=da.arange(1000).reshape((10, 10, 10)), label='d1')
app = GlueApplication()
session = app.session
hub = session.hub
data_collection = session.data_collection
data_collection.append(data)
viewer = app.new_data_viewer(HistogramViewer)
viewer.add_data(data)
viewer.state.hist_n_bin = 1
process_events(0.5)
assert len(viewer.layers) == 1
assert viewer.layers[0].enabled
zid, yid, xid = data.pixel_component_ids
subset_state = RoiSubsetState(xatt=xid, yatt=yid,
roi=RectangularROI(xmin=3.5, xmax=5.5, ymin=3.7, ymax=7.5))
data_collection.new_subset_group(subset_state=subset_state, label='subset')
assert len(viewer.layers) == 2
assert viewer.layers[0].enabled
assert viewer.layers[1].enabled
assert viewer.state.layers[0].histogram[1][0] == 1000.
assert viewer.state.layers[1].histogram[1][0] == 80.
viewer.close()
viewer = None
app.close()
app = None
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/data_viewer.py 0000644 0001750 0001750 00000002215 13605357235 024322 0 ustar noahfx noahfx from glue.utils import defer_draw, decorate_all_methods
from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.histogram.qt.layer_style_editor import HistogramLayerStyleEditor
from glue.viewers.histogram.qt.options_widget import HistogramOptionsWidget
from glue.viewers.histogram.qt.layer_artist import QThreadedHistogramLayerArtist
from glue.viewers.histogram.state import HistogramViewerState
from glue.viewers.histogram.viewer import MatplotlibHistogramMixin
__all__ = ['HistogramViewer']
@decorate_all_methods(defer_draw)
class HistogramViewer(MatplotlibHistogramMixin, MatplotlibDataViewer):
LABEL = '1D Histogram'
_layer_style_widget_cls = HistogramLayerStyleEditor
_options_cls = HistogramOptionsWidget
_state_cls = HistogramViewerState
_data_artist_cls = QThreadedHistogramLayerArtist
_subset_artist_cls = QThreadedHistogramLayerArtist
large_data_size = 2e7
tools = ['select:xrange']
def __init__(self, session, parent=None, state=None):
super(HistogramViewer, self).__init__(session, parent=parent, state=state)
MatplotlibHistogramMixin.setup_callbacks(self)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/options_widget.ui 0000644 0001750 0001750 00000032643 13661230662 025057 0 ustar noahfx noahfx
Widget
0
0
269
418
1D Histogram
5
5
5
5
5
-
0
General
10
10
10
10
10
5
-
0
0
5
0
0
0
0
-
normalized
true
-
cumulative
true
-
log
true
-
Qt::Horizontal
1
20
-
-
50
false
bins
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Update bins to view
-
Qt::Horizontal
40
5
-
Qt::Vertical
QSizePolicy::Fixed
20
5
-
Qt::Vertical
20
40
-
-
75
true
y axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
Fixed # of numerical bins
-
75
true
x axis
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
true
1000
-
QComboBox::AdjustToMinimumContentsLength
-
log
true
Limits
10
10
10
10
10
5
-
padding: 0px
⇄
-
-
-
-
75
true
x axis
-
75
true
y axis
-
Qt::Vertical
20
40
-
-
Qt::Horizontal
40
5
-
log
true
-
log
true
bool_x_log
valuetext_x_max
button_flip_x
valuetext_x_min
valuetext_y_min
valuetext_y_max
bool_y_log
label_2
label_5
verticalSpacer
horizontalSpacer_2
Axes
5
5
5
5
-
Legend
5
5
5
5
-
AxesEditorWidget
QWidget
glue.viewers.matplotlib.qt.axes_editor
LegendEditorWidget
QWidget
glue.viewers.matplotlib.qt.legend_editor
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/__init__.py 0000644 0001750 0001750 00000000211 13502206677 023560 0 ustar noahfx noahfx from .data_viewer import HistogramViewer # noqa
def setup():
from glue.config import qt_client
qt_client.add(HistogramViewer)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/layer_artist.py 0000644 0001750 0001750 00000004442 13662760562 024542 0 ustar noahfx noahfx import time
from glue.utils import defer_draw
from glue.viewers.histogram.layer_artist import HistogramLayerArtist
from glue.viewers.matplotlib.qt.compute_worker import ComputeWorker
__all__ = ['QThreadedHistogramLayerArtist']
class QThreadedHistogramLayerArtist(HistogramLayerArtist):
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(QThreadedHistogramLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
self.setup_thread()
def wait(self):
# Wait 0.5 seconds to make sure that the computation has properly started
time.sleep(0.5)
while self._worker.running:
time.sleep(1 / 25)
from glue.utils.qt import process_events
process_events()
def remove(self):
super(QThreadedHistogramLayerArtist, self).remove()
if self._worker is not None:
self._worker.work_queue.put('stop')
self._worker.exit()
# Need to wait otherwise the thread will be destroyed while still
# running, causing a segmentation fault
self._worker.wait()
self._worker = None
@property
def is_computing(self):
return self._worker is not None and self._worker.running
def setup_thread(self):
self._worker = ComputeWorker(self._calculate_histogram_thread)
self._worker.compute_end.connect(self._calculate_histogram_postthread)
self._worker.compute_error.connect(self._calculate_histogram_error)
self._worker.compute_start.connect(self.notify_start_computation)
self._worker.start()
@defer_draw
def _calculate_histogram(self, reset=False):
if self.state.layer is not None and self.state.layer.size > 1e7:
self._worker.work_queue.put(reset)
else:
super(QThreadedHistogramLayerArtist, self)._calculate_histogram(reset=reset)
def _calculate_histogram_postthread(self):
# If the worker has started running again, we should stop at this point
# since this function will get called again.
if self._worker is not None and self._worker.running:
return
super(QThreadedHistogramLayerArtist, self)._calculate_histogram_postthread()
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/options_widget.py 0000644 0001750 0001750 00000003547 13752534424 025077 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui, fix_tab_widget_fontsize
from glue.viewers.matplotlib.state import MatplotlibDataViewerState
__all__ = ['HistogramOptionsWidget']
class HistogramOptionsWidget(QtWidgets.QWidget):
def __init__(self, viewer_state, session, parent=None):
super(HistogramOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self._connections = autoconnect_callbacks_to_qt(viewer_state, self.ui)
self._connections_axes = autoconnect_callbacks_to_qt(viewer_state, self.ui.axes_editor.ui)
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections_legend = autoconnect_callbacks_to_qt(viewer_state.legend, self.ui.legend_editor.ui, connect_kwargs)
self.viewer_state = viewer_state
viewer_state.add_callback('x_att', self._update_attribute)
self.session = session
self.ui.axes_editor.button_apply_all.clicked.connect(self._apply_all_viewers)
def _apply_all_viewers(self):
for tab in self.session.application.viewers:
for viewer in tab:
if isinstance(viewer.state, MatplotlibDataViewerState):
viewer.state.update_axes_settings_from(self.viewer_state)
def _update_attribute(self, *args):
# If at least one of the components is categorical or a date, disable log button
log_enabled = 'categorical' not in self.viewer_state.x_kinds
self.ui.bool_x_log.setEnabled(log_enabled)
self.ui.bool_x_log_.setEnabled(log_enabled)
if not log_enabled:
self.ui.bool_x_log.setChecked(False)
self.ui.bool_x_log_.setChecked(False)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/layer_style_editor.ui 0000644 0001750 0001750 00000006103 13502206677 025716 0 ustar noahfx noahfx
Form
0
0
154
96
Form
5
5
5
5
10
5
-
0
0
-
75
true
color
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
75
true
opacity
Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter
-
100
Qt::Horizontal
-
Qt::Vertical
20
40
-
Qt::Horizontal
40
5
QColorBox
QLabel
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/qt/layer_style_editor.py 0000644 0001750 0001750 00000001072 13657331513 025730 0 ustar noahfx noahfx import os
from qtpy import QtWidgets
from echo.qt import autoconnect_callbacks_to_qt
from glue.utils.qt import load_ui
class HistogramLayerStyleEditor(QtWidgets.QWidget):
def __init__(self, layer, parent=None):
super(HistogramLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/python_export.py 0000644 0001750 0001750 00000004665 13661230662 024335 0 ustar noahfx noahfx from distutils.version import LooseVersion
from matplotlib import __version__
from glue.viewers.common.python_export import code, serialize_options
from glue.utils import nanmin, nanmax
MATPLOTLIB_GE_30 = LooseVersion(__version__) > '3'
def python_export_histogram_layer(layer, *args):
if len(layer.mpl_artists) == 0 or not layer.enabled or not layer.visible:
return [], None
script = ""
imports = ["import numpy as np"]
x = layer.layer[layer._viewer_state.x_att]
x_min = nanmin(x)
x_max = nanmax(x)
hist_x_min = layer._viewer_state.hist_x_min
hist_x_max = layer._viewer_state.hist_x_max
script += "# Get main data values\n"
script += "x = layer_data['{0}']\n\n".format(layer._viewer_state.x_att.label)
script += "# Set up histogram bins\n"
script += "hist_n_bin = {0}\n".format(layer._viewer_state.hist_n_bin)
if abs((x_min - hist_x_min) / (hist_x_max - hist_x_min)) < 0.001:
script += "hist_x_min = np.nanmin(x)\n"
else:
script += "hist_x_min = {0}\n".format(hist_x_min)
if abs((x_max - hist_x_max) / (hist_x_max - hist_x_min)) < 0.001:
script += "hist_x_max = np.nanmax(x)\n"
else:
script += "hist_x_max = {0}\n".format(hist_x_max)
options = dict(alpha=layer.state.alpha,
color=layer.state.color,
zorder=layer.state.zorder,
edgecolor='none')
if layer._viewer_state.x_log:
script += "bins = np.logspace(np.log10(hist_x_min), np.log10(hist_x_max), hist_n_bin)\n"
options['bins'] = code('bins')
else:
options['range'] = code('[hist_x_min, hist_x_max]')
options['bins'] = code('hist_n_bin')
if layer._viewer_state.normalize:
if MATPLOTLIB_GE_30:
options['density'] = True
else:
options['normed'] = True
if layer._viewer_state.cumulative:
options['cumulative'] = True
script += "\nx = x[(x >= hist_x_min) & (x <= hist_x_max)]\n\n"
script += "ax.hist(x, {0})\n\n".format(serialize_options(options))
options = dict(
facecolor=layer.state.color,
edgecolor='none',
alpha=layer.state.alpha)
imports += ["from matplotlib.patches import Patch"]
script += "handle = Patch({0}) # for legend\n".format(serialize_options(options))
script += "legend_handles.append(handle)\n"
script += "legend_labels.append(layer_data.label)\n"
return imports, script.strip()
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/state.py 0000644 0001750 0001750 00000023143 13662766630 022535 0 ustar noahfx noahfx import numpy as np
from glue.core import BaseData, Subset
from echo import delay_callback
from glue.viewers.matplotlib.state import (MatplotlibDataViewerState,
MatplotlibLayerState,
DeferredDrawCallbackProperty as DDCProperty,
DeferredDrawSelectionCallbackProperty as DDSCProperty)
from glue.core.state_objects import (StateAttributeLimitsHelper,
StateAttributeHistogramHelper)
from glue.core.exceptions import IncompatibleAttribute, IncompatibleDataException
from glue.core.data_combo_helper import ComponentIDComboHelper
from glue.utils import defer_draw, datetime64_to_mpl
from glue.utils.decorators import avoid_circular
__all__ = ['HistogramViewerState', 'HistogramLayerState']
class HistogramViewerState(MatplotlibDataViewerState):
"""
A state class that includes all the attributes for a histogram viewer.
"""
x_att = DDSCProperty(docstring='The attribute to compute the histograms for')
cumulative = DDCProperty(False, docstring='Whether to show the histogram as '
'a cumulative histogram')
normalize = DDCProperty(False, docstring='Whether to normalize the histogram '
'(based on the total sum)')
hist_x_min = DDCProperty(docstring='The minimum value used to compute the '
'histogram')
hist_x_max = DDCProperty(docstring='The maximum value used to compute the '
'histogram')
hist_n_bin = DDCProperty(docstring='The number of bins in the histogram')
common_n_bin = DDCProperty(True, docstring='The number of bins to use for '
'all numerical components')
def __init__(self, **kwargs):
super(HistogramViewerState, self).__init__()
self.hist_helper = StateAttributeHistogramHelper(self, 'x_att', lower='hist_x_min',
upper='hist_x_max', n_bin='hist_n_bin',
common_n_bin='common_n_bin')
self.x_lim_helper = StateAttributeLimitsHelper(self, 'x_att', lower='x_min',
upper='x_max', log='x_log')
self.add_callback('layers', self._layers_changed)
self.x_att_helper = ComponentIDComboHelper(self, 'x_att',
pixel_coord=True, world_coord=True)
self.update_from_dict(kwargs)
# This should be added after update_from_dict since we don't want to
# influence the restoring of sessions.
self.add_callback('hist_x_min', self.update_view_to_bins)
self.add_callback('hist_x_max', self.update_view_to_bins)
self.add_callback('x_log', self._reset_x_limits, priority=1000)
def _reset_x_limits(self, *args):
if self.x_att is None:
return
with delay_callback(self, 'hist_x_min', 'hist_x_max', 'x_min', 'x_max', 'x_log'):
self.x_lim_helper.percentile = 100
self.x_lim_helper.update_values(force=True)
self.update_bins_to_view()
def reset_limits(self):
self._reset_x_limits()
self.y_min = min(getattr(layer, '_y_min', np.inf) for layer in self.layers)
self.y_max = max(getattr(layer, '_y_max', 0) for layer in self.layers)
def _update_priority(self, name):
if name == 'layers':
return 2
elif name.endswith('_log'):
return 0.5
elif name.endswith(('_min', '_max', '_bin')):
return 0
else:
return 1
def flip_x(self):
"""
Flip the x_min/x_max limits.
"""
self.x_lim_helper.flip_limits()
@avoid_circular
def update_bins_to_view(self, *args):
"""
Update the bins to match the current view.
"""
with delay_callback(self, 'hist_x_min', 'hist_x_max'):
if self.x_max > self.x_min:
self.hist_x_min = self.x_min
self.hist_x_max = self.x_max
else:
self.hist_x_min = self.x_max
self.hist_x_max = self.x_min
@avoid_circular
def update_view_to_bins(self, *args):
"""
Update the view to match the histogram interval
"""
with delay_callback(self, 'x_min', 'x_max'):
self.x_min = self.hist_x_min
self.x_max = self.hist_x_max
@property
def x_categories(self):
return self._categories(self.x_att)
def _categories(self, cid):
categories = []
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer = layer_state.layer
else:
layer = layer_state.layer.data
try:
if layer.data.get_kind(cid) == 'categorical':
categories.append(layer.data.get_data(cid).categories)
except IncompatibleAttribute:
pass
if len(categories) == 0:
return None
else:
return np.unique(np.hstack(categories))
@property
def x_kinds(self):
return self._component_kinds(self.x_att)
def _component_kinds(self, cid):
# Construct list of component kinds over all layers
kinds = set()
for layer_state in self.layers:
if isinstance(layer_state.layer, BaseData):
layer = layer_state.layer
else:
layer = layer_state.layer.data
try:
kinds.add(layer.data.get_kind(cid))
except IncompatibleAttribute:
pass
return kinds
@property
def bins(self):
"""
The position of the bins for the histogram based on the current state.
"""
if self.hist_x_min is None or self.hist_x_max is None or self.hist_n_bin is None:
return None
if self.x_log:
return np.logspace(np.log10(self.hist_x_min),
np.log10(self.hist_x_max),
self.hist_n_bin + 1)
elif isinstance(self.hist_x_min, np.datetime64):
x_min = self.hist_x_min.astype(int)
x_max = self.hist_x_max.astype(self.hist_x_min.dtype).astype(int)
return np.linspace(x_min, x_max, self.hist_n_bin + 1).astype(self.hist_x_min.dtype)
else:
return np.linspace(self.hist_x_min, self.hist_x_max,
self.hist_n_bin + 1)
@defer_draw
def _layers_changed(self, *args):
self.x_att_helper.set_multiple_data(self.layers_data)
class HistogramLayerState(MatplotlibLayerState):
"""
A state class that includes all the attributes for layers in a histogram plot.
"""
_histogram_cache = None
def reset_cache(self, *args):
self._histogram_cache = None
@property
def viewer_state(self):
return self._viewer_state
@viewer_state.setter
def viewer_state(self, viewer_state):
self._viewer_state = viewer_state
@property
def histogram(self):
self.update_histogram()
edges, unscaled = self._histogram_cache[1]
scaled = unscaled.astype(np.float)
dx = edges[1] - edges[0]
if self.viewer_state.cumulative:
scaled = scaled.cumsum()
if self.viewer_state.normalize:
scaled /= scaled.max()
elif self.viewer_state.normalize:
scaled /= (scaled.sum() * dx)
return edges, scaled
def update_histogram(self):
current_settings = (id(self.viewer_state.x_att),
self.viewer_state.x_log,
self.viewer_state.hist_x_min,
self.viewer_state.hist_x_max,
self.viewer_state.hist_n_bin)
if self._histogram_cache is not None and self._histogram_cache[0] == current_settings:
return self._histogram_cache[1]
if (self.viewer_state is None or self.viewer_state.x_att is None or
self.viewer_state.hist_x_min is None or self.viewer_state.hist_x_max is None or
self.viewer_state.hist_n_bin is None or self.viewer_state.x_log is None):
raise IncompatibleDataException()
if isinstance(self.layer, Subset):
data = self.layer.data
subset_state = self.layer.subset_state
else:
data = self.layer
subset_state = None
range = sorted((self.viewer_state.hist_x_min, self.viewer_state.hist_x_max))
hist_values = data.compute_histogram([self._viewer_state.x_att],
range=[range],
bins=[self._viewer_state.hist_n_bin],
log=[self._viewer_state.x_log],
subset_state=subset_state)
# TODO: determine whether this belongs here or in the layer artist
if isinstance(range[0], np.datetime64):
range = [datetime64_to_mpl(range[0]), datetime64_to_mpl(range[1])]
if self._viewer_state.x_log:
hist_edges = np.logspace(np.log10(range[0]), np.log10(range[1]),
self._viewer_state.hist_n_bin + 1)
else:
hist_edges = np.linspace(range[0], range[1],
self._viewer_state.hist_n_bin + 1)
self._histogram_cache = current_settings, (hist_edges, hist_values)
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/__init__.py 0000644 0001750 0001750 00000000000 13502206677 023130 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/compat.py 0000644 0001750 0001750 00000004247 13605357235 022676 0 ustar noahfx noahfx import uuid
from .state import HistogramLayerState
STATE_CLASS = {}
STATE_CLASS['HistogramLayerArtist'] = HistogramLayerState
def update_histogram_viewer_state(rec, context):
"""
Given viewer session information, make sure the session information is
compatible with the current version of the viewers, and if not, update
the session information in-place.
"""
if '_protocol' not in rec:
# Note that files saved with protocol < 1 have bin settings saved per
# layer but they were always restricted to be the same, so we can just
# use the settings from the first layer
rec['state'] = {}
rec['state']['values'] = {}
# TODO: could generalize this into a mapping
properties = rec.pop('properties')
viewer_state = rec['state']['values']
viewer_state['x_min'] = properties['xmin']
viewer_state['x_max'] = properties['xmax']
viewer_state['hist_n_bin'] = int(properties['nbins'])
viewer_state['hist_x_min'] = properties['xmin']
viewer_state['hist_x_max'] = properties['xmax']
viewer_state['x_log'] = properties['xlog']
viewer_state['y_log'] = properties['ylog']
viewer_state['normalize'] = properties['normed']
viewer_state['cumulative'] = properties['cumulative']
viewer_state['x_att'] = properties['component']
layer_states = []
for layer in rec['layers']:
state_id = str(uuid.uuid4())
state_cls = STATE_CLASS[layer['_type'].split('.')[-1]]
state = state_cls(layer=context.object(layer.pop('layer')))
for prop in ('visible', 'zorder'):
value = layer.pop(prop)
value = context.object(value)
setattr(state, prop, value)
context.register_object(state_id, state)
layer['state'] = state_id
layer_states.append(state)
layer.pop('lo', None)
layer.pop('hi', None)
layer.pop('nbins', None)
layer.pop('xlog', None)
list_id = str(uuid.uuid4())
context.register_object(list_id, layer_states)
rec['state']['values']['layers'] = list_id
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/layer_artist.py 0000644 0001750 0001750 00000015561 13662766630 024124 0 ustar noahfx noahfx import sys
import warnings
import numpy as np
from matplotlib.patches import Rectangle, Patch
from glue.utils import defer_draw
from glue.core import BaseData
from glue.viewers.histogram.state import HistogramLayerState
from glue.viewers.histogram.python_export import python_export_histogram_layer
from glue.viewers.matplotlib.layer_artist import MatplotlibLayerArtist
from glue.core.exceptions import IncompatibleAttribute, IncompatibleDataException
class HistogramLayerArtist(MatplotlibLayerArtist):
_layer_state_cls = HistogramLayerState
_python_exporter = python_export_histogram_layer
def __init__(self, axes, viewer_state, layer_state=None, layer=None):
super(HistogramLayerArtist, self).__init__(axes, viewer_state,
layer_state=layer_state, layer=layer)
# Watch for changes in the viewer state which would require the
# layers to be redrawn
self._viewer_state.add_global_callback(self._update_histogram)
self.state.add_global_callback(self._update_histogram)
@defer_draw
def _calculate_histogram(self, reset=False):
try:
self.notify_start_computation()
self._calculate_histogram_thread(reset=reset)
except Exception:
self._calculate_histogram_error(sys.exc_info())
else:
self._calculate_histogram_postthread()
def _calculate_histogram_thread(self, reset=False):
# We need to ignore any warnings that happen inside the thread
# otherwise the thread tries to send these to the glue logger (which
# uses Qt), which then results in this kind of error:
# QObject::connect: Cannot queue arguments of type 'QTextCursor'
with warnings.catch_warnings():
warnings.simplefilter("ignore")
if reset:
self.state.reset_cache()
self.state.update_histogram()
def _calculate_histogram_postthread(self):
self.notify_end_computation()
self._update_artists()
self._update_visual_attributes()
@defer_draw
def _calculate_histogram_error(self, exc):
self.notify_end_computation()
self.redraw()
if issubclass(exc[0], (IncompatibleAttribute, IndexError)):
if isinstance(self.state.layer, BaseData):
self.disable_invalid_attributes(self._viewer_state.x_att)
else:
self.disable_incompatible_subset()
elif issubclass(exc[0], IncompatibleDataException):
self.disable("Incompatible data")
@defer_draw
def _update_artists(self):
# It's possible for this method to get called but for the state to have
# been updated in the mean time to have a histogram that raises an
# exception (for example an IncompatibleAttribute). If any errors happen
# here, we simply ignore them since _calculate_histogram_error will get
# called directly.
try:
mpl_hist_edges, mpl_hist = self.state.histogram
except Exception:
return
if mpl_hist_edges.size == 0 or mpl_hist.sum() == 0:
return
if len(self.mpl_artists) > len(mpl_hist):
for artist in self.mpl_artists[len(mpl_hist):]:
artist.remove()
self.mpl_artists = self.mpl_artists[:len(mpl_hist)]
elif len(self.mpl_artists) < len(mpl_hist):
for i in range(len(mpl_hist) - len(self.mpl_artists)):
artist = Rectangle((0, 0), 0, 0)
self.mpl_artists.append(artist)
self.axes.add_artist(artist)
self._update_visual_attributes()
widths = np.diff(mpl_hist_edges)
bottom = 0 if not self._viewer_state.y_log else 1e-100
for mpl_artist, x, y, dx in zip(self.mpl_artists, mpl_hist_edges[:-1], mpl_hist, widths):
mpl_artist.set_width(dx)
mpl_artist.set_height(y)
mpl_artist.set_xy((x, bottom))
# TODO: move the following to state
# We have to do the following to make sure that we reset the y_max as
# needed. We can't simply reset based on the maximum for this layer
# because other layers might have other values, and we also can't do:
#
# self._viewer_state.y_max = max(self._viewer_state.y_max, result[0].max())
#
# because this would never allow y_max to get smaller.
self.state._y_max = mpl_hist.max()
if self._viewer_state.y_log:
self.state._y_max *= 2
else:
self.state._y_max *= 1.2
if self._viewer_state.y_log:
keep = mpl_hist > 0
if np.any(keep):
self.state._y_min = mpl_hist[mpl_hist > 0].min() / 10
else:
self.state._y_min = 0
else:
self.state._y_min = 0
largest_y_max = max(getattr(layer, '_y_max', 0) for layer in self._viewer_state.layers)
if largest_y_max != self._viewer_state.y_max:
self._viewer_state.y_max = largest_y_max
smallest_y_min = min(getattr(layer, '_y_min', np.inf) for layer in self._viewer_state.layers)
if smallest_y_min != self._viewer_state.y_min:
self._viewer_state.y_min = smallest_y_min
self.redraw()
@defer_draw
def _update_visual_attributes(self):
if not self.enabled:
return
for mpl_artist in self.mpl_artists:
mpl_artist.set_visible(self.state.visible)
mpl_artist.set_zorder(self.state.zorder)
mpl_artist.set_edgecolor('none')
mpl_artist.set_facecolor(self.state.color)
mpl_artist.set_alpha(self.state.alpha)
self.redraw()
def _update_histogram(self, force=False, **kwargs):
if (self._viewer_state.hist_x_min is None or
self._viewer_state.hist_x_max is None or
self._viewer_state.hist_n_bin is None or
self._viewer_state.x_att is None or
self.state.layer is None):
return
changed = set() if force else self.pop_changed_properties()
if force or any(prop in changed for prop in ('layer', 'x_att', 'hist_x_min', 'hist_x_max', 'hist_n_bin', 'x_log', 'y_log', 'normalize', 'cumulative')):
self._calculate_histogram(reset=force)
if force or any(prop in changed for prop in ('alpha', 'color', 'zorder', 'visible')):
self._update_visual_attributes()
def get_handle_legend(self):
# The default legend handle for matplotlib viewer
if self.enabled and self.state.visible:
handle = Patch(facecolor=self.get_layer_color(), edgecolor='none', alpha=self.layer.style.alpha)
return handle, self.layer.label, None
else:
return None, None, None
@defer_draw
def update(self):
self.state.reset_cache()
self._update_histogram(force=True)
self.redraw()
glueviz-1.0.1+dfsg.orig/glue/viewers/histogram/viewer.py 0000644 0001750 0001750 00000004737 13605357235 022720 0 ustar noahfx noahfx from glue.core.util import update_ticks
from glue.core.roi import RangeROI
from glue.core.subset import roi_to_subset_state
from glue.utils import mpl_to_datetime64
from glue.viewers.histogram.compat import update_histogram_viewer_state
__all__ = ['MatplotlibHistogramMixin']
class MatplotlibHistogramMixin(object):
def setup_callbacks(self):
self.state.add_callback('x_att', self._update_axes)
self.state.add_callback('x_log', self._update_axes)
self.state.add_callback('normalize', self._update_axes)
self._update_axes()
def _update_axes(self, *args):
if self.state.x_att is not None:
# Update ticks, which sets the labels to categories if components are categorical
update_ticks(self.axes, 'x', self.state.x_kinds, self.state.x_log, self.state.x_categories)
if self.state.x_log:
self.state.x_axislabel = 'Log ' + self.state.x_att.label
else:
self.state.x_axislabel = self.state.x_att.label
if self.state.normalize:
self.state.y_axislabel = 'Normalized number'
else:
self.state.y_axislabel = 'Number'
self.axes.figure.canvas.draw_idle()
def apply_roi(self, roi, override_mode=None):
# Force redraw to get rid of ROI. We do this because applying the
# subset state below might end up not having an effect on the viewer,
# for example there may not be any layers, or the active subset may not
# be one of the layers. So we just explicitly redraw here to make sure
# a redraw will happen after this method is called.
self.redraw()
if len(self.layers) == 0:
return
x_date = 'datetime' in self.state.x_kinds
if x_date:
roi = roi.transformed(xfunc=mpl_to_datetime64 if x_date else None)
bins = self.state.bins
x = roi.to_polygon()[0]
lo, hi = min(x), max(x)
if lo >= bins.min():
lo = bins[bins <= lo].max()
if hi <= bins.max():
hi = bins[bins >= hi].min()
roi_new = RangeROI(min=lo, max=hi, orientation='x')
subset_state = roi_to_subset_state(roi_new, x_att=self.state.x_att,
x_categories=self.state.x_categories)
self.apply_subset_state(subset_state, override_mode=override_mode)
@staticmethod
def update_viewer_state(rec, context):
return update_histogram_viewer_state(rec, context)
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/ 0000755 0001750 0001750 00000000000 13752535025 020345 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/tests/ 0000755 0001750 0001750 00000000000 13752535025 021507 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 023613 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/ 0000755 0001750 0001750 00000000000 13752535025 020771 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/tests/ 0000755 0001750 0001750 00000000000 13752535025 022133 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 024237 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/tests/test_elements.py 0000644 0001750 0001750 00000003347 13605357235 025371 0 ustar noahfx noahfx import pytest
from glue.core.state_objects import State
from ..elements import (FormElement, NumberElement, ChoiceElement,
FloatElement, TextBoxElement)
def get_value(element):
prefix, widget_cls, property = element.ui_and_state()
class TemporaryState(State):
a = property
temp = TemporaryState()
return temp.a
class TestFormElements(object):
def test_number_default_value(self):
e = FormElement.auto((0, 100, 30))
assert get_value(e) == 30
def test_number_float(self):
e = FormElement.auto((0.0, 1.0, 0.3))
assert get_value(e) == 0.3
def test_number_list(self):
e = FormElement.auto([0, 10])
assert isinstance(e, NumberElement)
def test_choice_list(self):
e = FormElement.auto(['a', 'b'])
assert isinstance(e, ChoiceElement)
def test_choice_tuple(self):
e = FormElement.auto(('a', 'b'))
assert isinstance(e, ChoiceElement)
def test_float(self):
e = FormElement.auto(1.2)
assert isinstance(e, FloatElement)
e = FormElement.auto(2)
assert isinstance(e, FloatElement)
assert get_value(e) == 2
def test_textbox(self):
e = FormElement.auto('_str')
assert isinstance(e, TextBoxElement)
assert get_value(e) == 'str'
def test_recognizes_subsubclasses(self):
class SubClassFormElement(TextBoxElement):
@classmethod
def recognizes(cls, params):
return params == 'specific_class'
e = FormElement.auto('specific_class')
assert isinstance(e, SubClassFormElement)
def test_unrecognized(self):
with pytest.raises(ValueError):
FormElement.auto(None)
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/tests/test_custom_viewer.py 0000644 0001750 0001750 00000022340 13605357235 026442 0 ustar noahfx noahfx from collections import OrderedDict
import numpy as np
from matplotlib.axes import Axes
from unittest.mock import MagicMock
from numpy.testing import assert_array_equal
from glue.core.tests.test_state import clone
from glue.core.tests.util import simple_session
from glue.core.subset import SubsetState
from glue.core import Data
from glue import custom_viewer
from glue.app.qt import GlueApplication
from glue.app.qt.tests.test_application import check_clone_app
from ..custom_viewer import CustomViewer, CustomSubsetState, AttributeWithInfo
def _make_widget(viewer):
s = simple_session()
return viewer._viewer_cls(s)
viewer = custom_viewer('Testing Custom Viewer',
a=(0, 100),
b='att',
c='att(x)',
d=True,
e=False,
f=['a', 'b', 'c'],
g=OrderedDict(a=1, b=2, c=3),
h=64
)
setup = MagicMock()
settings_changed = MagicMock()
plot_subset = MagicMock()
plot_data = MagicMock()
make_selector = MagicMock()
make_selector.return_value = MagicMock(spec=SubsetState)
make_selector().copy.return_value = MagicMock(spec=SubsetState)
make_selector().copy().to_mask.return_value = np.array([False, True, True])
@viewer.setup
def _setup(axes):
setup(axes)
@viewer.plot_data
def _plot_data(axes, a, b, g, h):
plot_data(axes=axes, a=a, b=b, g=g, h=h)
return []
@viewer.plot_subset
def _plot_subset(b, c, d, e, f, style):
plot_subset(b=b, c=c, d=d, e=e, f=f, style=style)
return []
@viewer.settings_changed
def _settings_changed(state):
settings_changed(state=state)
@viewer.make_selector
def _make_selector(roi, c):
make_selector(roi=roi, c=c)
return SubsetState()
def test_custom_classes_dont_share_methods():
"""Regression test for #479"""
a = custom_viewer('a')
b = custom_viewer('b')
assert a._custom_functions is not b._custom_functions
class ViewerSubclass(CustomViewer):
a = (0, 100)
b = 'att'
c = 'att(x)'
d = True
e = False
f = ['a', 'b', 'c']
g = OrderedDict(a=1, b=2, c=3)
h = 64
def setup(self, axes):
return setup(axes)
def plot_data(self, axes, a, b, g, h):
return plot_data(axes=axes, a=a, b=b, g=g, h=h)
def plot_subset(self, b, c, d, e, f, style):
return plot_subset(b=b, c=c, d=d, e=e, f=f, style=style)
def settings_changed(self, state):
return settings_changed(state=state)
def make_selector(self, roi, c):
return make_selector(roi=roi, c=c)
class TestCustomViewer(object):
def setup_class(self):
self.viewer = viewer
def setup_method(self, method):
setup.reset_mock()
settings_changed.reset_mock()
plot_subset.reset_mock()
plot_data.reset_mock()
make_selector.reset_mock()
self.data = Data(x=[1, 2, 3], y=[2, 3, 4])
self.session = simple_session()
self.dc = self.session.data_collection
self.dc.append(self.data)
def teardown_method(self, method):
if hasattr(self, 'w'):
self.w.unregister(self.session.hub)
def build(self):
w = self.viewer._viewer_cls(self.session)
w.register_to_hub(self.session.hub)
self.w = w
return w
def test_setup_called_on_init(self):
ct = setup.call_count
self.build()
assert setup.call_count == ct + 1
def test_separate_widgets_have_separate_state(self):
w1 = self.build()
w2 = self.build()
assert w1._coordinator is not w2._coordinator
assert w1._coordinator.state is not w2._coordinator.state
def test_plot_data(self):
w = self.build()
w.add_data(self.data)
a, k = plot_data.call_args
assert isinstance(k['axes'], Axes)
assert set(k.keys()) == set(('axes', 'a', 'b', 'g', 'h'))
assert k['a'] == 50
assert k['g'] == 1
assert k['h'] == 64
def test_plot_subset(self):
w = self.build()
w.add_data(self.data)
self.dc.new_subset_group(subset_state=self.data.id['x'] > 2)
a, k = plot_subset.call_args
assert set(k.keys()) == set(('b', 'c', 'd', 'e', 'f', 'style'))
assert_array_equal(k['b'], [3])
assert_array_equal(k['c'], [3])
assert k['d']
assert not k['e']
assert k['f'] == 'a'
def test_make_selector(self):
w = self.build()
w.add_data(self.data)
roi = MagicMock()
w.apply_roi(roi)
a, k = make_selector.call_args
assert set(k.keys()) == set(('roi', 'c'))
assert k['roi'] is roi
def test_settings_change(self):
w = self.build()
ct = settings_changed.call_count
w.options_widget().bool_d.setChecked(False)
assert settings_changed.call_count == ct + 1
a, k = settings_changed.call_args
assert 'state' in k
def test_component_autoupdate(self):
w = self.build()
w.add_data(self.data)
assert w.options_widget().combosel_b.count() == 2
self.data.add_component([10, 20, 30], label='c')
assert w.options_widget().combosel_b.count() == 3
def test_settings_changed_called_on_init(self):
self.build()
assert settings_changed.call_count == 1
def test_selections_enabled(self):
w = self.build()
assert w._coordinator.selections_enabled
assert 'select:rectangle' in w.toolbar.tools
assert 'select:polygon' in w.toolbar.tools
def test_state_save():
app = GlueApplication()
w = app.new_data_viewer(viewer._viewer_cls) # noqa
check_clone_app(app)
def test_state_save_with_data_layers():
app = GlueApplication()
dc = app.data_collection
d = Data(x=[1, 2, 3], label='test')
dc.append(d)
w = app.new_data_viewer(viewer._viewer_cls)
w.add_data(d)
check_clone_app(app)
class TestCustomSelectMethod(object):
def setup_class(self):
self.viewer = custom_viewer('CustomSelectViewer',
x='att(x)', flip=False)
@self.viewer.select
def select(roi, x, flip):
if flip:
return x <= 1
return x > 1
def setup_method(self, method):
self.data = Data(x=[1, 2, 3], y=[2, 3, 4])
self.session = simple_session()
self.dc = self.session.data_collection
self.dc.append(self.data)
def build(self):
return self.viewer._viewer_cls(self.session)
def test_subset_state(self):
w = self.build()
v = w._coordinator
roi = MagicMock()
s = CustomSubsetState(v, roi)
assert_array_equal(s.to_mask(self.data), [False, True, True])
def test_subset_state_view(self):
w = self.build()
v = w._coordinator
roi = MagicMock()
s = CustomSubsetState(v, roi)
assert_array_equal(s.to_mask(self.data, view=slice(None, None, 2)),
[False, True])
def test_settings_frozen_at_creation(self):
w = self.build()
v = w._coordinator
roi = MagicMock()
s = CustomSubsetState(v, roi)
w.flip = True
assert_array_equal(s.to_mask(self.data), [False, True, True])
def test_save_load(self):
app = GlueApplication(session=self.session)
w = app.new_data_viewer(self.viewer._viewer_cls)
v = w._coordinator
roi = None
s = CustomSubsetState(v, roi)
app.data_collection.new_subset_group(subset_state=s, label='test')
app2 = clone(app)
s2 = app2.data_collection[0].subsets[0].subset_state
assert_array_equal(s2.to_mask(self.data), [False, True, True])
class TestCustomViewerSubclassForm(TestCustomViewer):
def setup_class(self):
self.viewer = ViewerSubclass
class TestAttributeWithInfo(object):
def setup_method(self, method):
d = Data(x=[1, 2, 3, 4, 5], c=['a', 'b', 'a', 'a', 'b'], label='test')
s = d.new_subset()
s.subset_state = d.id['x'] > 2
self.d = d
self.s = s
def test_numerical(self):
v = AttributeWithInfo.from_layer(self.d, self.d.id['x'])
assert_array_equal(v, [1, 2, 3, 4, 5])
assert v.id == self.d.id['x']
assert v.categories is None
def test_categorical(self):
v = AttributeWithInfo.from_layer(self.d, self.d.id['c'])
assert_array_equal(v, [0, 1, 0, 0, 1])
assert v.id == self.d.id['c']
assert_array_equal(v.categories, ['a', 'b'])
def test_subset(self):
v = AttributeWithInfo.from_layer(self.s, self.d.id['x'])
assert_array_equal(v, [3, 4, 5])
assert v.id == self.d.id['x']
assert v.categories is None
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._viewer_cls)
app.new_data_viewer(MyWidget2._viewer_cls)
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/elements.py 0000644 0001750 0001750 00000017107 13657331513 023165 0 ustar noahfx noahfx from echo import CallbackProperty, SelectionCallbackProperty
from qtpy.QtWidgets import (QSlider, QLineEdit, QComboBox, QWidget,
QLabel, QHBoxLayout, QCheckBox)
from qtpy.QtCore import Qt
__all__ = ["FormElement", "NumberElement", "TextBoxElement", "FloatElement",
"BoolElement", "ChoiceElement", "FixedComponentIDProperty",
"FixedComponentElement", "ComponenentElement", "DynamicComponentIDProperty"]
class QLabeledSlider(QWidget):
"""
A labeled slider widget
"""
range = None
integer = None
def __init__(self, parent=None):
super(QLabeledSlider, self).__init__(parent)
self._range = range
self._slider = QSlider()
self._slider.setMinimum(0)
self._slider.setMaximum(100)
self._slider.setOrientation(Qt.Horizontal)
self._label = QLabel('')
self._layout = QHBoxLayout()
self._layout.setContentsMargins(2, 2, 2, 2)
self._layout.addWidget(self._slider)
self._layout.addWidget(self._label)
self._slider.valueChanged.connect(self._update_label)
self.setLayout(self._layout)
def _update_label(self, *args):
self._label.setText(str(self.value()))
@property
def valueChanged(self):
return self._slider.valueChanged
def value(self, layer=None, view=None):
value = self._slider.value() / 100. * (self.range[1] - self.range[0]) + self.range[0]
if self.integer:
return int(value)
else:
return(value)
_in_set_value = False
def setValue(self, value):
if self._in_set_value:
return
self._in_set_value = True
value = int(100 * (value - self.range[0]) / (self.range[1] - self.range[0]))
self._slider.setValue(value)
self._in_set_value = False
class FormElement(object):
"""
Base class for user-defined settings in a custom widget.
Each form element has a value() and a widget. Subclasses
must override _build_ui, value, and recognizes. They
may override register_to_hub and add_data.
"""
def __init__(self, params):
self.params = params
@classmethod
def recognizes(cls, params):
"""
Returns whether or not a shorthand "params" object
can be passed to __init__ to construct an element
"""
raise NotImplementedError
def ui_and_state(self):
"""
Build and return a widget to represent this setting.
"""
raise NotImplementedError()
@staticmethod
def auto(params):
"""
Construct the appropriate FormElement subclass,
given a shorthand object. For examle,
FormElement.auto((0., 1.)) returns a NumberElement
"""
def subclasses(cls):
return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in subclasses(s)]
for cls in subclasses(FormElement):
if cls.recognizes(params):
return cls(params)
raise ValueError("Unrecognzied UI Component: %s" % (params,))
class NumberElement(FormElement):
"""
A form element representing a number
The shorthand is a tuple of 2 or 3 numbers:
(min, max) or (min, max default)::
e = FormElement.auto((0., 1.))
"""
@classmethod
def recognizes(cls, params):
try:
if len(params) not in [2, 3]:
return False
return all(isinstance(p, (int, float)) for p in params)
except TypeError:
return False
def ui_and_state(self):
if len(self.params) == 3:
default = self.params[2]
else:
default = 0.5 * (self.params[0] + self.params[1])
# We can't initialize QLabeledSlider yet because this could get called
# before the Qt application has been initialized. So for now we just make
# a subclass of QLabeledSlider with the range we need
class CustomSlider(QLabeledSlider):
range = self.params[:2]
integer = isinstance(self.params[0], int) and isinstance(self.params[1], int)
return 'value_', CustomSlider, CallbackProperty(default)
class TextBoxElement(FormElement):
"""
A form element representing a generic textbox
The shorthand is any string starting with an _.::
e = FormElement.auto("_default")
Everything after the underscore is taken as the default value.
"""
@classmethod
def recognizes(cls, params):
try:
if isinstance(params, str) & params.startswith('_'):
return True
except AttributeError:
return None
def ui_and_state(self):
default = self.params[1:]
return 'text_', QLineEdit, CallbackProperty(default)
class FloatElement(FormElement):
"""
A form element representing a generic number box.
The shorthand is any number::
e = FormElement.auto(2)
The number itself is taken as the default value.
"""
@classmethod
def recognizes(cls, params):
return isinstance(params, (int, float)) and not isinstance(params, bool)
def ui_and_state(self):
default = self.params
return 'valuetext_', QLineEdit, CallbackProperty(default)
class BoolElement(FormElement):
"""
A checkbox representing a boolean setting
The shorthand notation is True or False::
e = FormElement.auto(False)
"""
@classmethod
def recognizes(cls, params):
return isinstance(params, bool)
def ui_and_state(self):
default = self.params
return 'bool_', QCheckBox, CallbackProperty(default)
class ChoiceElement(FormElement):
"""
A dropdown selector to choose between a set of items
Shorthand notation is a sequence of strings or a dict::
e = FormElement.auto({'a':1, 'b':2})
e = FormElement.auto(['a', 'b', 'c'])
"""
@classmethod
def recognizes(cls, params):
if isinstance(params, str):
return False
try:
return all(isinstance(p, str) for p in params)
except TypeError:
return False
def ui_and_state(self):
if isinstance(self.params, list):
choices = self.params
display_func = None
else:
params_inv = dict((value, key) for key, value in self.params.items())
choices = list(params_inv.keys())
display_func = params_inv.get
property = SelectionCallbackProperty(default_index=0, choices=choices,
display_func=display_func)
return 'combosel_', QComboBox, property
class FixedComponentIDProperty(CallbackProperty):
pass
class FixedComponentElement(FormElement):
"""
An element for a Data Component. Does not have a widget
The shorthand notation is 'att(comp_name)'::
e = FormElement.auto('att(foo)')
"""
@classmethod
def recognizes(cls, params):
try:
return params.startswith('att(')
except AttributeError:
return False
def ui_and_state(self):
component_name = self.params.split('(')[-1][:-1]
return None, None, FixedComponentIDProperty(component_name)
class DynamicComponentIDProperty(SelectionCallbackProperty):
pass
class ComponenentElement(FormElement):
"""
A dropdown selector to choose a component
The shorthand notation is 'att'::
e = FormElement.auto('att')
"""
@classmethod
def recognizes(cls, params):
return params == 'att'
def ui_and_state(self):
return 'combosel_', QComboBox, DynamicComponentIDProperty()
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/__init__.py 0000644 0001750 0001750 00000000045 13605357235 023103 0 ustar noahfx noahfx from .custom_viewer import * # noqa
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/qt/custom_viewer.py 0000644 0001750 0001750 00000060727 13657331513 024252 0 ustar noahfx noahfx """
This module provides utilities for creating custom data viewers. The goal of
this module is to make it easy for users to make new data viewers by focusing on
matplotlib visualization logic, and not UI or event processing logic.
The end user typically interacts with this code via :func:`glue.custom_viewer`
"""
# Implementation notes:
#
# Here's a high-level summary of how this code works right now:
#
# The user creates a custom viewer using either of the following
# syntaxes:
#
#
# from glue import custom_viewer
# my_viewer = custom_viewer('my viewer', checked=True, x='att', ...)
# @my_viewer.plot_data
# def plot_data(x, checked, axes):
# if checked:
# axes.plot(x)
# ...
#
# or
#
# from glue.viewers.custom.qt import CustomViewer
# class MyViewer(CustomViewer):
#
# checked = True
# x = 'att'
#
# def plot_data(self, x, checked, axes):
# if checked:
# axes.plot(x)
#
# This code has two "magic" features:
#
# 1. Attributes like 'checked' and 'x', passed as kwargs to custom_viewer
# or set as class-level attributes in the subclass, are turned
# into widgets based on their value
#
# 2. Functions like plot_data can take these settings as input (as well
# as some general purpose arguments like axes). Glue takes care of
# passing the proper arguments to these functions by introspecting
# their call signature. Furthermore, it extracts the current
# value of each setting (ie checked is set to True or False depending
# on what if the box is checked).
#
# The intention of all of this magic is to let a user write "simple" functions
# to draw custom plots, without having to use Glue or Qt logic directly.
#
# Internally, Glue accomlishes this magic as follows:
#
# `FormElement`s are created for each attribute in (1). They build the widget
# and have a method of extracting the current value of the widget
#
# Functions like `plot_data` that are designed to be overriden by users
# are defined as custom descriptors -- when called at the class level,
# they become decorators that wrap and register the user-defined function.
# When called at the instance level, they become dispatch functions which
# deal with the logic in (2). The metaclass deals with registering
# UDFs when they are overridden in a subclass.
from inspect import getmodule
from functools import partial
from inspect import getfullargspec
from types import FunctionType, MethodType
import numpy as np
from qtpy.QtWidgets import QWidget, QGridLayout, QLabel
from echo.qt import autoconnect_callbacks_to_qt
from glue.config import qt_client
from glue.core import BaseData
from glue.core.subset import SubsetState
from glue.core.data_combo_helper import ComponentIDComboHelper
from glue.core.component_id import ComponentID
from glue.utils import as_list, all_artists, new_artists, categorical_ndarray, defer_draw
from glue.viewers.matplotlib.qt.data_viewer import MatplotlibDataViewer
from glue.viewers.matplotlib.state import MatplotlibDataViewerState, MatplotlibLayerState
from glue.viewers.matplotlib.layer_artist import MatplotlibLayerArtist
from glue.viewers.custom.qt.elements import (FormElement,
DynamicComponentIDProperty,
FixedComponentIDProperty)
__all__ = ["AttributeWithInfo", "ViewerUserState", "UserDefinedFunction",
"CustomViewer", "CustomViewerMeta", "CustomSubsetState",
"CustomViewer", "CustomLayerArtist", "CustomMatplotlibDataViewer"]
class AttributeWithInfo(np.ndarray):
"""
An array subclass wrapping a Component of a dataset It is an array with the
following additional attributes: ``id`` contains the ComponentID or string
name of the Component, and ``categories`` is an array or `None`. For
categorical Components, it contains the distinct categories which are
integer-encoded in the AttributeWithInfo
"""
@classmethod
def make(cls, id, values, categories=None):
values = np.asarray(values)
result = values.view(AttributeWithInfo)
result.id = id
result.values = values
result.categories = categories
return result
@classmethod
def from_layer(cls, layer, cid, view=None):
"""
Build an AttributeWithInfo out of a subset or dataset.
Parameters
----------
layer : :class:`~glue.core.data.Data` or :class:`~glue.core.subset.Subset`
The data to use
cid : ComponentID
The ComponentID to use
view : numpy-style view (optional)
What slice into the data to use
"""
values = layer[cid, view]
if isinstance(values, categorical_ndarray):
categories = values.categories
values = values.codes
else:
categories = None
return cls.make(cid, values, categories)
def __gluestate__(self, context):
return dict(cid=context.id(self.id))
@classmethod
def __setgluestate__(cls, rec, context):
return cls.make(context.object(rec['cid']), [], None)
class ViewerUserState(object):
"""
Empty object for users to store data inside.
"""
def __gluestate__(self, context):
return dict(data=[(k, context.id(v)) for k, v in self.__dict__.items()])
@classmethod
def __setgluestate__(cls, rec, context):
result = cls()
rec = rec['data']
for k in rec:
setattr(result, k, context.object(rec[k]))
return result
class UserDefinedFunction(object):
"""
Descriptor to specify a UserDefinedFunction.
Defined in CustomViewer like this::
class CustomViewer(object):
...
plot_data = UserDefinedFunction('plot_data')
The descriptor gives CustomViewer.plot_data a dual functionality.
When accessed at the class level, it behaves as a decorator to
register new UDFs::
cv = custom_viewer(...)
@cv.plot_data # becomes a decorator
def plot_data_implementation(...):
...
When accessed at the instance level, it becomes a dispatch function
that calls `plot_data_implementation` with the proper arguments
Alternatively, plot_data_implementation can be specified by explicitly
overriding plot_data in a subclass. A metaclass takes care of registering
the UDF in that case, so you can define plot_data as a normal
(non-decorator, non-descriptor) method.
"""
def __init__(self, name):
self.name = name
def __get__(self, instance, cls=None):
if instance is None:
# accessed from class level, return a decorator
# to wrap a custom UDF
return partial(cls._register_override_method, self.name)
# method called at instance level,
# return a dispatcher to the UDF
return partial(instance._call_udf, self.name)
def introspect_and_call(func, state, override):
"""
Introspect a function for its arguments, extract values for those
arguments from a state class, and call the function
Parameters
----------
func : function
A function to call. It should not define any keywords
state : State
A state class containing the values to pass
override : dict
A dictionary containing values that should override the state
Returns
-------
The result of calling func with the proper arguments
*Example*
def a(x, y):
return x, y
introspect_and_call(a, state) will return
a(state.x, state.y)
Attributes will be used from ``override`` before ``state``.
"""
a, k = getfullargspec(func)[:2]
args = []
for item in a:
if item in override:
args.append(override[item])
elif hasattr(state, item):
args.append(getattr(state, item))
else:
setting_list = "\n -".join(state.callback_properties() + list(override))
raise MissingSettingError("This custom viewer is trying to use an "
"unrecognized variable named %s\n. Valid "
"variable names are\n -%s" %
(item, setting_list))
k = k or {}
return func(*args, **k)
class MissingSettingError(KeyError):
pass
class CustomViewerMeta(type):
"""
Metaclass to construct CustomViewer and subclasses
The metaclass does two things when constructing new
classes:
- it finds the class-level attributes that describe
ui elements (eg `checked=False`). It bundles these
into a `ui` dict attribute, later used to construct
the FormElements and widgets to represent each setting
- It creates the qt DataViewer widget class associated with this class.
- It looks for overridden user-defined methods like `plot_subset`,
and registers them for later use.
"""
def __new__(cls, name, bases, attrs):
# don't muck with the base class
if name == 'CustomViewer':
return type.__new__(cls, name, bases, attrs)
# Find ui elements
ui = {}
for key, value in list(attrs.items()):
if key.startswith('_') or key in CustomViewer.__dict__:
continue
if not isinstance(value, (MethodType, FunctionType)):
ui[key] = attrs.pop(key)
attrs['ui'] = ui
attrs.setdefault('name', name)
# collect the user defined functions
udfs = {}
for nm, value in list(attrs.items()):
dscr = CustomViewer.__dict__.get(nm, None)
if isinstance(dscr, UserDefinedFunction):
# remove them as class method
# register them below instead
udfs[nm] = attrs.pop(nm)
result = type.__new__(cls, name, bases, attrs)
result._custom_functions = {}
# now wrap the custom user defined functions using the descriptors
for k, v in udfs.items():
# register UDF by mimicing the decorator syntax
udf_decorator = getattr(result, k)
udf_decorator(v)
result._build_data_viewer()
return result
class CustomSubsetState(SubsetState):
"""
A SubsetState subclass that uses a CustomViewer's "select" function
"""
def __init__(self, coordinator, roi):
super(CustomSubsetState, self).__init__()
self._coordinator = coordinator
self._roi = roi
def to_mask(self, data, view=None):
return self._coordinator.select(layer=data, roi=self._roi, view=view)
def copy(self):
return CustomSubsetState(self._coordinator, self._roi)
def __gluestate__(self, context):
result = {}
result['viewer'] = context.id(self._coordinator.viewer)
result['roi'] = context.id(self._roi)
return result
@classmethod
def __setgluestate__(cls, rec, context):
roi = context.object(rec['roi'])
subset_state = cls(None, roi)
subset_state._viewer_rec = rec['viewer']
return subset_state
def __setgluestate_callback__(self, context):
# When __setgluestate__ is created, the viewers might not yet be
# deserialized, and these depend on the Data and Subsets existing so
# we need to deserialize the viewer in a callback so it can be called
# later on.
viewer = context.object(self._viewer_rec)
self._coordinator = viewer._coordinator
self._viewer_rec = None
class BaseCustomOptionsWidget(QWidget):
"""
Base class for the Qt widget which will be used to show the options.
"""
_widgets = None
def __init__(self, viewer_state=None, session=None):
super(BaseCustomOptionsWidget, self).__init__()
layout = QGridLayout()
for row, (name, (prefix, viewer_cls)) in enumerate(self._widgets.items()):
widget = viewer_cls()
setattr(self, prefix + name, widget)
layout.addWidget(QLabel(name.capitalize()), row, 0)
layout.addWidget(widget, row, 1)
if len(self._widgets) > 0:
layout.setRowStretch(row + 1, 10)
self.setLayout(layout)
self.viewer_state = viewer_state
self.session = session
self._connections = autoconnect_callbacks_to_qt(self.viewer_state, self)
class CustomViewer(object, metaclass=CustomViewerMeta):
"""
Base class for custom data viewers.
Users can either subclass this class and override
one or more custom methods listed below, or use the
:func:`glue.custom_viewer` function and decorate custom
plot functions.
*Custom Plot Methods*
The following methods can be overridden:
- :meth:`CustomViewer.setup`
- :meth:`CustomViewer.plot_data`
- :meth:`CustomViewer.plot_subset`
- :meth:`CustomViewer.settings_changed`
- :meth:`CustomViewer.make_selector`
- :meth:`CustomViewer.select`
*Method Signatures*
Custom methods should use argument names from the following list:
- The name of a UI element (e.g. keywords passed to :func:`glue.custom_viewer`,
or class-level variables in subclasses). The value assigned to this
argument will be the current UI setting (e.g. booleans for checkboxes).
- ``axes`` will contain a matplotlib Axes object
- ``roi`` will contain the ROI a user has drawn (only available for ``make_selector``)
- ``state`` will contain a general-purpose object to store other data
- ``style`` contains the :class:`~glue.core.visual.VisualAttributes` describing
a subset or dataset. Only available for ``plot_data`` and `plot_subset``
- ``subset`` will contain the relevant :class:`~glue.core.subset.Subset` object.
Only available for ``plot_subset``
*Defining the UI*
Simple widget-based UIs can be specified by providing keywords to :func:`~glue.custom_viewer`
or class-level variables to subsets. The kind of widget to associate with each
UI element is determined from it's type.
*Example decorator*
::
v = custom_viewer('Example', checkbox=False)
@v.plot_data
def plot(checkbox, axes):
axes.plot([1, 2, 3])
*Example subclass*
::
class CustomViewerSubset(CustomViewer):
checkbox = False
def plot_data(self, checkbox, axes):
axes.plot([1, 2, 3])
The order of arguments can be listed in any order.
"""
# Label to give this widget in the GUI
name = ''
# Container to hold user descriptions of desired FormElements to create
ui = {}
# map, e.g., 'plot_data' -> user defined function - we also make sure we
# override this in sub-classes in CustomViewerMeta
_custom_functions = {}
def __init__(self, viewer):
self.viewer = viewer
self.state = ViewerUserState()
self.setup()
@property
def selections_enabled(self):
return 'make_selector' in self._custom_functions or 'select' in self._custom_functions
@classmethod
def create_new_subclass(cls, name, **kwargs):
"""
Convenience method to build a new CustomViewer subclass.
This is used by the custom_viewer function.
Parameters
----------
name : str
Name of the new viewer
kwargs
UI elements in the subclass
"""
kwargs = kwargs.copy()
kwargs['name'] = name
# each subclass needs its own dict
kwargs['_custom_functions'] = {}
name = name.replace(' ', '')
return CustomViewerMeta(name, (CustomViewer,), kwargs)
@classmethod
def _build_data_viewer(cls):
"""
Build the DataViewer subclass for this viewer.
"""
# At this point, the metaclass has put all the user options in a dict
# called .ui, so we go over this dictionary and find the widgets and
# callback properties for each of them.
widgets = {}
properties = {}
for name in sorted(cls.ui):
value = cls.ui[name]
prefix, widget, property = FormElement.auto(value).ui_and_state()
if widget is not None:
widgets[name] = prefix, widget
properties[name] = property
options_cls = type(cls.__name__ + 'OptionsWidget',
(BaseCustomOptionsWidget,), {'_widgets': widgets})
state_cls = type(cls.__name__ + 'ViewerState', (CustomMatplotlibViewerState,), properties)
widget_dict = {'LABEL': cls.name,
'ui': cls.ui,
'_options_cls': options_cls,
'_state_cls': state_cls,
'_coordinator_cls': cls}
viewer_cls = type(cls.__name__ + 'DataViewer',
(CustomMatplotlibDataViewer,),
widget_dict)
cls._viewer_cls = viewer_cls
qt_client.add(viewer_cls)
# add new classes to module namespace
# needed for proper state saving/restoring
for c in [viewer_cls, cls]:
mod = getmodule(ViewerUserState)
w = getattr(mod, c.__name__, None)
if w is not None:
raise RuntimeError("Duplicate custom viewer detected %s" % c)
setattr(mod, c.__name__, c)
c.__module__ = mod.__name__
@classmethod
def _register_override_method(cls, name, func):
"""
Register a new custom method like "plot_data"
Users need not call this directly - it is called when a method is
overridden or decorated
"""
cls._custom_functions[name] = func
def _build_subset_state(self, roi):
if 'make_selector' in self._custom_functions:
return self.make_selector(roi=roi)
if 'select' in self._custom_functions:
return CustomSubsetState(self, roi)
raise RuntimeError("Selection not supported for this viewer.")
# List of user-defined functions.
# Users can either use these as decorators to
# wrap custom functions, or override them in subclasses.
setup = UserDefinedFunction('setup')
"""
Custom method called when plot is created
"""
plot_subset = UserDefinedFunction('plot_subset')
"""
Custom method called to show a subset
"""
plot_data = UserDefinedFunction('plot_data')
"""
Custom method called to show a dataset
"""
make_selector = UserDefinedFunction('make_selector')
"""
Custom method called to build a :class:`~glue.core.subset.SubsetState` from an ROI.
See :meth:`~CustomViewer.select` for an alternative way to define selections,
by returning Boolean arrays instead of SubsetStates.
Functions have access to the roi by accepting an ``roi``
argument to this function
"""
settings_changed = UserDefinedFunction('settings_changed')
"""
Custom method called when UI settings change.
"""
select = UserDefinedFunction('select')
"""
Custom method called to filter data using an ROI.
This is an alternative function to :meth:`~CustomViewer.make_selector`,
which returns a numpy boolean array instead of a SubsetState.
Functions have access to the roi by accepting an ``roi``
argument to this function
"""
def _call_udf(self, method_name, **kwargs):
"""
Call a user-defined function stored in the _custom_functions dict
Parameters
----------
method_name : str
The name of the user-defined method to setup a dispatch for
use_cid : bool, optional
Whether to pass component IDs to the user function instead of the
data itself.
**kwargs : dict
Custom settings to pass to the UDF if they are requested by name
as input arguments
Returns
-------
The result of the UDF
Notes
-----
This function builds the necessary arguments to the
user-defined function. It also attempts to monitor
the state of the matplotlib plot, removing stale
artists and re-rendering the canvas as needed.
"""
# get the custom function
try:
func = self._custom_functions[method_name]
except KeyError:
return []
override = kwargs.copy()
if 'layer' not in override and len(self.viewer.state.layers) > 0:
override['layer'] = self.viewer.state.layers[0].layer
if 'layer' in override:
override.setdefault('style', override['layer'].style)
# Dereference attributes
for name, property in self.viewer.state.iter_callback_properties():
value = getattr(self.viewer.state, name)
if isinstance(value, ComponentID) or isinstance(property, FixedComponentIDProperty):
override[name] = AttributeWithInfo.from_layer(override['layer'], value, view=override.get('view', None))
# add some extra information that the user might want
override.setdefault('self', self)
override.setdefault('axes', self.viewer.axes)
override.setdefault('figure', self.viewer.axes.figure)
override.setdefault('state', self.state)
# call method, keep track of newly-added artists
result = introspect_and_call(func, self.viewer.state, override)
self.viewer.redraw()
return result
class CustomLayerArtist(MatplotlibLayerArtist):
"""
LayerArtist for simple custom viewers that use Matplotlib
"""
_layer_state_cls = MatplotlibLayerState
def __init__(self, coordinator, *args, **kwargs):
super(CustomLayerArtist, self).__init__(*args, **kwargs)
self._coordinator = coordinator
self.state.add_global_callback(self.update)
self._viewer_state.add_global_callback(self.update)
def update(self, *args, **kwargs):
if not self._visible:
return
self.clear()
old = all_artists(self.axes.figure)
if isinstance(self.state.layer, BaseData):
a = self._coordinator.plot_data(layer=self.state.layer)
else:
a = self._coordinator.plot_subset(layer=self.state.layer, subset=self.state.layer)
# if user explicitly returns the newly-created artists,
# then use them. Otherwise, introspect to find the new artists
if a is None:
self.mpl_artists = list(new_artists(self.axes.figure, old))
else:
self.mpl_artists = as_list(a)
for a in self.mpl_artists:
a.set_zorder(self.state.zorder)
class CustomMatplotlibDataViewer(MatplotlibDataViewer):
"""
Base Qt widget class for simple custom viewers that use Matplotlib
"""
LABEL = ''
tools = ['select:rectangle', 'select:polygon']
_state_cls = None
_options_cls = None
_layer_style_viewer_cls = None
_data_artist_cls = CustomLayerArtist
_subset_artist_cls = CustomLayerArtist
_coordinator_cls = None
def __init__(self, session, parent=None, **kwargs):
super(CustomMatplotlibDataViewer, self).__init__(session, parent, **kwargs)
self._coordinator = self._coordinator_cls(self)
self.state.add_global_callback(self._on_state_change)
self._on_state_change()
def _on_state_change(self, *args, **kwargs):
self._coordinator.settings_changed()
def get_layer_artist(self, cls, layer=None, layer_state=None):
return cls(self._coordinator, self.axes, self.state, layer=layer, layer_state=layer_state)
@defer_draw
def apply_roi(self, roi):
# Force redraw to get rid of ROI. We do this because applying the
# subset state below might end up not having an effect on the viewer,
# for example there may not be any layers, or the active subset may not
# be one of the layers. So we just explicitly redraw here to make sure
# a redraw will happen after this method is called.
self.redraw()
if len(self.layers) == 0:
return
subset_state = self._coordinator._build_subset_state(roi=roi)
self.apply_subset_state(subset_state)
class CustomMatplotlibViewerState(MatplotlibDataViewerState):
def __init__(self, *args, **kwargs):
super(CustomMatplotlibViewerState, self).__init__(*args)
self._cid_helpers = []
for name, property in self.iter_callback_properties():
if isinstance(property, DynamicComponentIDProperty):
self._cid_helpers.append(ComponentIDComboHelper(self, name))
self.add_callback('layers', self._on_layer_change)
self.update_from_dict(kwargs)
def _on_layer_change(self, *args):
for helper in self._cid_helpers:
helper.set_multiple_data(self.layers_data)
glueviz-1.0.1+dfsg.orig/glue/viewers/custom/__init__.py 0000644 0001750 0001750 00000000000 13455362716 022451 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/viewers/custom/helper.py 0000644 0001750 0001750 00000007405 13502206677 022205 0 ustar noahfx noahfx # This is a helper function that gets imported into the top-level namespace of glue.
__all__ = ['custom_viewer']
def custom_viewer(name, **kwargs):
"""
Create a custom interactive data viewer.
To use this, first create a new variable by calling custom_viewer.
Then, register one or more viewer functions using decorators.
:param name: The name of the new viewer
:type name: str
Named arguments are used to build widgets and pass data
to viewer functions. See ``specifying widgets`` below.
Example::
v = custom_viewer('My custom viewer', check=False, x='att(x)')
@v.setup
def setup_func(axes):
''' Setup the plot when the viewer is created '''
...
@v.plot_data
def plot_data_func(axes, check, style):
''' Visualize a full dataset '''
...
@v.plot_subset
def plot_subset_func(axes, check, style):
''' Visualize a subset '''
...
@v.update_settings
def update_settings_func(check):
''' Respond to the user changing a widget setting '''
...
@v.select
def select(roi, x):
''' Filter a dataset based on an roi. Return a boolean array '''
...
@v.make_selector
def make_selector_func(roi):
''' Turn a roi into a subset state '''
...
**Specifying Widgets**
Keywords passed to ``custom_viewer`` serve two purposes: they
setup information to be passed into the viewer functions, and
they create widgets. The type of widget that is created depends
on the keyword value:
* ``keyword=False | True`` creates a checkbox. The check state
is passed as a Boolean into the viewer functions
* ``keyword=(10, 20, [15])`` creates a slider. The current value
of the slider is passed as a number to the viewer functions.
The first two numbers specify the minimum and maximum allowed value,
while the optional third number specifies the initial value.
* ``keyword=['a', 'b', 'c']`` creates a dropdown menu. The current
selection is passed as a string to the viewer functions.
* ``keyword={'a':1, 'b':2}`` behaves similarly to the lists above,
but uses the keys as dropdown labels and values as the setting
passed to viewer functions.
* ``keyword='att(foo)'`` doesn't create any widget, but passes
in the attribute named ``foo`` to the viewer functions, as an
:class:`~glue.viewers.custom.qt.custom_viewer.AttributeWithInfo` object.
* ``keyword='att'`` creates a dropdown to let the user select
one of the attributes from the data. The selected attribute
is passed as an :class:`~glue.viewers.custom.qt.custom_viewer.AttributeWithInfo`
**Viewer Functions**
Custom viewers can implement any of the following functions:
* ``setup_func`` is called once, when the viewer is created.
* ``plot_data`` is called to update the visualization of a
full dataset.
* ``plot_subset`` is used to visualize data subsets.
* ``update_settings`` is called whenever a user modifies
a widget setting.
* ``select`` specifies how user-drawn regions on the viewer
are used to filter data. It has access to an :class:`~glue.core.roi.Roi`
input, and returns a Boolean array testing whether each element
in a dataset is part of a subset.
* ``make_selector`` is an alternative to ``select``. Instead of returning
an array, ``make_selector`` returns a :class:`~glue.core.subset.SubsetState`
"""
# For now we only support Qt, but this function should be extended to work
# with non-Qt front-ends in future.
from glue.viewers.custom.qt import CustomViewer
return CustomViewer.create_new_subclass(name, **kwargs)
glueviz-1.0.1+dfsg.orig/glue/external/ 0000755 0001750 0001750 00000000000 13752535025 017171 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/tests/ 0000755 0001750 0001750 00000000000 13752535025 020333 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/tests/__init__.py 0000644 0001750 0001750 00000000000 13455362716 022437 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/echo/ 0000755 0001750 0001750 00000000000 13752535025 020107 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/echo/qt/ 0000755 0001750 0001750 00000000000 13752535025 020533 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/echo/qt/__init__.py 0000644 0001750 0001750 00000000026 13657331513 022642 0 ustar noahfx noahfx from echo.qt import *
glueviz-1.0.1+dfsg.orig/glue/external/echo/qt/connect.py 0000644 0001750 0001750 00000000134 13657331513 022534 0 ustar noahfx noahfx from echo.qt.connect import *
from echo.qt.connect import _find_combo_data, UserDataWrapper
glueviz-1.0.1+dfsg.orig/glue/external/echo/qt/autoconnect.py 0000644 0001750 0001750 00000000113 13657331513 023422 0 ustar noahfx noahfx from echo.qt.autoconnect import *
from echo.qt.autoconnect import HANDLERS
glueviz-1.0.1+dfsg.orig/glue/external/echo/core.py 0000644 0001750 0001750 00000000030 13657331513 021402 0 ustar noahfx noahfx from echo.core import *
glueviz-1.0.1+dfsg.orig/glue/external/echo/list.py 0000644 0001750 0001750 00000000036 13657331513 021433 0 ustar noahfx noahfx from echo.containers import *
glueviz-1.0.1+dfsg.orig/glue/external/echo/__init__.py 0000644 0001750 0001750 00000000170 13657331513 022216 0 ustar noahfx noahfx import warnings
from echo import *
warnings.warn('glue.external.echo is deprecated, import from echo directly instead')
glueviz-1.0.1+dfsg.orig/glue/external/echo/selection.py 0000644 0001750 0001750 00000000035 13657331513 022444 0 ustar noahfx noahfx from echo.selection import *
glueviz-1.0.1+dfsg.orig/glue/external/echo/callback_container.py 0000644 0001750 0001750 00000000046 13657331513 024257 0 ustar noahfx noahfx from echo.callback_container import *
glueviz-1.0.1+dfsg.orig/glue/external/__init__.py 0000644 0001750 0001750 00000000222 13502206677 021277 0 ustar noahfx noahfx """
Modules in this directory smooth over importing functionality that may be
present in different libraries, depending on the users' system.
"""
glueviz-1.0.1+dfsg.orig/glue/external/axescache.py 0000644 0001750 0001750 00000014323 13507416115 021466 0 ustar noahfx noahfx """
The AxesCache class alters how an Axes instance is rendered.
While enabled, the AxesCache quickly re-renders an original view,
properly scaled and translated to reflect changes in the viewport.
The downside is that the re-rendered image is fuzzy and/or truncated.
The best way to use an AxesCache is to enable it during
window resize drags and pan/zoom mouse drags; these generate
rapid draw requests, and users might prefer high refresh
rates to pixel-perfect renders.
Unfortunately, Matplotlib on it's own doesn't provide an easy
mechanism to attach event handlers to either window resize drags
or pan/zoom drags. This code must be added separately.
"""
import numpy as np
from matplotlib.axes import Axes
from matplotlib.image import AxesImage
from matplotlib.collections import QuadMesh
class RenderCapture(object):
"""
A RemderCapture saves an image of a fully-rendered
Axes instance, and provides a method for re-rendering
a properly transformed image during panning and zooming
"""
def __init__(self, axes, renderer):
self.axes = axes
self._corners = self._get_corners(axes)
px, py, dx, dy = self._corners
im = self.extract_image(renderer)
im = im[py[0]: py[-1] + 1, px[0]: px[-1] + 1, :]
self.im = im
self._mesh = None
self._image = None
self.image
@property
def image(self):
if self._image is not None:
return self._image
px, py, dx, dy = self._corners
self._image = AxesImage(self.axes,
origin='lower',
interpolation='nearest')
self._image.set_data(self.im)
self._image.set_extent((dx[0], dx[-1], dy[0], dy[-1]))
self.axes._set_artist_props(self._image)
return self._image
@property
def mesh(self):
if self._mesh is not None:
return self._mesh
px, py, dx, dy = self._corners
x, y, c = self.axes._pcolorargs('pcolormesh', dx, dy,
self.im[:, :, 0],
allmatch=False)
ny, nx = x.shape
coords = np.column_stack((x.ravel(), y.ravel()))
collection = QuadMesh(nx - 1, ny - 1, coords,
shading='flat', antialiased=False,
edgecolors='None',
cmap='gray')
collection.set_array(c.ravel())
collection.set_clip_path(self.axes.patch)
collection.set_transform(self.axes.transData)
self._mesh = collection
return self._mesh
def draw(self, renderer, *args, **kwargs):
if self.axes.get_xscale() == 'linear' and \
self.axes.get_yscale() == 'linear':
self.image.draw(renderer, *args, **kwargs)
else:
self.mesh.draw(renderer, *args, **kwargs)
@staticmethod
def _get_corners(axes):
"""
Return the device and data coordinates
for a box slightly inset from the edge
of an axes instance
Returns 4 1D arrays:
px : Pixel X locations for each column of the box
py : Pixel Y locations for each row of the box
dx : Data X locations for each column of the box
dy : Data Y locations for each row of the box
"""
xlim = axes.get_xlim()
ylim = axes.get_ylim()
pts = np.array([[xlim[0], ylim[0]],
[xlim[1], ylim[1]]])
corners = axes.transData.transform(pts).astype(np.int)
# move in 5 pixels, to avoid grabbing the tick marks
px = np.arange(corners[0, 0] + 5, corners[1, 0] - 5)
py = np.arange(corners[0, 1] + 5, corners[1, 1] - 5)
tr = axes.transData.inverted().transform
dx = tr(np.column_stack((px, px)))[:, 0]
dy = tr(np.column_stack((py, py)))[:, 1]
return px, py, dx, dy
@staticmethod
def extract_image(renderer):
try:
buf = renderer.buffer_rgba()
except TypeError: # mpl v1.1 has different signature
buf = renderer.buffer_rgba(0, 0)
result = np.frombuffer(buf, dtype=np.uint8)
result = result.reshape((int(renderer.height),
int(renderer.width), 4)).copy()
return np.flipud(result)
class AxesCache(object):
def __init__(self, axes):
self.axes = axes
self._capture = None
self.axes.draw = self.draw
self._enabled = False
def draw(self, renderer, *args, **kwargs):
if self._capture is None or not self._enabled:
Axes.draw(self.axes, renderer, *args, **kwargs)
if hasattr(renderer, 'buffer_rgba'):
self._capture = RenderCapture(self.axes, renderer)
else:
self.axes.axesPatch.draw(renderer, *args, **kwargs)
self._capture.draw(renderer, *args, **kwargs)
self.axes.xaxis.draw(renderer, *args, **kwargs)
self.axes.yaxis.draw(renderer, *args, **kwargs)
for s in self.axes.spines.values():
s.draw(renderer, *args, **kwargs)
def clear_cache(self):
"""
Clear the cache, forcing the a full re-render
"""
self._capture = None
def disable(self):
"""
Temporarily disable cache re-renders. Render
results are still saved, for when
enable() is next called
"""
self._enabled = False
self.axes.figure.canvas.draw_idle()
def enable(self):
"""
Enable cached-rerenders
"""
self._enabled = True
def teardown(self):
"""
Permanently disable this cache, and restore
normal Axes render behavior
"""
self.axes.draw = Axes.draw.__get__(self.axes)
if __name__ == "__main__":
import matplotlib.pyplot as plt
num = 1000000
plt.subplot(111)
plt.subplots_adjust(bottom=.5, top=.8)
plt.scatter(np.random.randn(num), np.random.randn(num),
s=np.random.randint(10, 50, num),
c=np.random.randint(0, 255, num),
alpha=.2, linewidths=0)
plt.plot([0, 1, 2, 3], [0, 1, 2, 3])
cache = AxesCache(plt.gca())
cache.enable()
plt.grid('on')
# plt.xscale('log')
plt.show()
glueviz-1.0.1+dfsg.orig/glue/external/modest_image.py 0000644 0001750 0001750 00000026712 13607640331 022204 0 ustar noahfx noahfx """
Modification of Chris Beaumont's mpl-modest-image package to allow the use of
set_extent.
"""
from __future__ import print_function, division
import matplotlib
rcParams = matplotlib.rcParams
import matplotlib.image as mi
import matplotlib.colors as mcolors
import matplotlib.cbook as cbook
from matplotlib.transforms import IdentityTransform, Affine2D
import numpy as np
IDENTITY_TRANSFORM = IdentityTransform()
class ModestImage(mi.AxesImage):
"""
Computationally modest image class.
ModestImage is an extension of the Matplotlib AxesImage class
better suited for the interactive display of larger images. Before
drawing, ModestImage resamples the data array based on the screen
resolution and view window. This has very little affect on the
appearance of the image, but can substantially cut down on
computation since calculations of unresolved or clipped pixels
are skipped.
The interface of ModestImage is the same as AxesImage. However, it
does not currently support setting the 'extent' property. There
may also be weird coordinate warping operations for images that
I'm not aware of. Don't expect those to work either.
"""
def __init__(self, *args, **kwargs):
self._pressed = False
self._full_res = None
self._full_extent = kwargs.get('extent', None)
super(ModestImage, self).__init__(*args, **kwargs)
self.invalidate_cache()
self.axes.figure.canvas.mpl_connect('button_press_event', self._press)
self.axes.figure.canvas.mpl_connect('button_release_event', self._release)
self.axes.figure.canvas.mpl_connect('resize_event', self._resize)
self._timer = self.axes.figure.canvas.new_timer(interval=500)
self._timer.single_shot = True
self._timer.add_callback(self._resize_paused)
def remove(self):
super(ModestImage, self).remove()
self._timer.stop()
self._timer = None
def _resize(self, *args):
self._pressed = True
self._timer.start()
def _resize_paused(self, *args):
# If the artist has been removed, self.axes is no longer defined, so
# we can return early here.
if self.axes is None:
return
self._pressed = False
self.axes.figure.canvas.draw_idle()
def _press(self, *args):
self._pressed = True
def _release(self, *args):
self._pressed = False
self.stale = True
self.axes.figure.canvas.draw_idle()
def set_data(self, A):
"""
Set the image array
ACCEPTS: numpy/PIL Image A
"""
self._full_res = A
self._A = A
if self._A.dtype != np.uint8 and not np.can_cast(self._A.dtype,
np.float):
raise TypeError("Image data can not convert to float")
if (self._A.ndim not in (2, 3) or
(self._A.ndim == 3 and self._A.shape[-1] not in (3, 4))):
raise TypeError("Invalid dimensions for image data")
self.invalidate_cache()
def invalidate_cache(self):
self._bounds = None
self._imcache = None
self._rgbacache = None
self._oldxslice = None
self._oldyslice = None
self._sx, self._sy = None, None
self._pixel2world_cache = None
self._world2pixel_cache = None
def get_cursor_data(self, event):
return None
def contains(self, mouseevent):
if self._A is None or self._A.shape is None:
return False
else:
return super(ModestImage, self).contains(mouseevent)
def set_extent(self, extent):
self._full_extent = extent
self.invalidate_cache()
mi.AxesImage.set_extent(self, extent)
def get_array(self):
"""Override to return the full-resolution array"""
return self._full_res
@property
def _pixel2world(self):
if self._pixel2world_cache is None:
# Pre-compute affine transforms to convert between the 'world'
# coordinates of the axes (what is shown by the axis labels) to
# 'pixel' coordinates in the underlying array.
extent = self._full_extent
if extent is None:
self._pixel2world_cache = IDENTITY_TRANSFORM
else:
self._pixel2world_cache = Affine2D()
self._pixel2world.translate(+0.5, +0.5)
self._pixel2world.scale((extent[1] - extent[0]) / self._full_res.shape[1],
(extent[3] - extent[2]) / self._full_res.shape[0])
self._pixel2world.translate(extent[0], extent[2])
self._world2pixel_cache = None
return self._pixel2world_cache
@property
def _world2pixel(self):
if self._world2pixel_cache is None:
self._world2pixel_cache = self._pixel2world.inverted()
return self._world2pixel_cache
def _scale_to_res(self):
"""
Change self._A and _extent to render an image whose resolution is
matched to the eventual rendering.
"""
# Find out how we need to slice the array to make sure we match the
# resolution of the display. We pass self._world2pixel which matters
# for cases where the extent has been set.
x0, x1, sx, y0, y1, sy = extract_matched_slices(axes=self.axes,
shape=self._full_res.shape,
transform=self._world2pixel)
# Check whether we've already calculated what we need, and if so just
# return without doing anything further.
if (self._bounds is not None and
sx >= self._sx and sy >= self._sy and
x0 >= self._bounds[0] and x1 <= self._bounds[1] and
y0 >= self._bounds[2] and y1 <= self._bounds[3]):
return
# Slice the array using the slices determined previously to optimally
# match the display
self._A = self._full_res[y0:y1:sy, x0:x1:sx]
self._A = cbook.safe_masked_invalid(self._A)
# We now determine the extent of the subset of the image, by determining
# it first in pixel space, and converting it to the 'world' coordinates.
# See https://github.com/matplotlib/matplotlib/issues/8693 for a
# demonstration of why origin='upper' and extent=None needs to be
# special-cased.
if self.origin == 'upper' and self._full_extent is None:
xmin, xmax, ymin, ymax = x0 - .5, x1 - .5, y1 - .5, y0 - .5
else:
xmin, xmax, ymin, ymax = x0 - .5, x1 - .5, y0 - .5, y1 - .5
xmin, ymin, xmax, ymax = self._pixel2world.transform([(xmin, ymin), (xmax, ymax)]).ravel()
mi.AxesImage.set_extent(self, [xmin, xmax, ymin, ymax])
# self.set_extent([xmin, xmax, ymin, ymax])
# Finally, we cache the current settings to avoid re-computing similar
# arrays in future.
self._sx = sx
self._sy = sy
self._bounds = (x0, x1, y0, y1)
self.changed()
def draw(self, renderer, *args, **kwargs):
if self._full_res.shape is None:
return
if not self._pressed or self._bounds is None:
self._scale_to_res()
# Due to a bug in Matplotlib, we need to return here if all values
# in the array are masked.
if hasattr(self._A, 'mask') and np.all(self._A.mask):
return
super(ModestImage, self).draw(renderer, *args, **kwargs)
def main():
from time import time
import matplotlib.pyplot as plt
x, y = np.mgrid[0:2000, 0:2000]
data = np.sin(x / 10.) * np.cos(y / 30.)
f = plt.figure()
ax = f.add_subplot(111)
# try switching between
artist = ModestImage(ax, data=data)
ax.set_aspect('equal')
artist.norm.vmin = -1
artist.norm.vmax = 1
ax.add_artist(artist)
t0 = time()
plt.gcf().canvas.draw_idle()
t1 = time()
print("Draw time for %s: %0.1f ms" % (artist.__class__.__name__,
(t1 - t0) * 1000))
plt.show()
def imshow(axes, X, cmap=None, norm=None, aspect=None,
interpolation=None, alpha=None, vmin=None, vmax=None,
origin=None, extent=None, shape=None, filternorm=1,
filterrad=4.0, imlim=None, resample=None, url=None, **kwargs):
"""Similar to matplotlib's imshow command, but produces a ModestImage
Unlike matplotlib version, must explicitly specify axes
"""
if norm is not None:
assert(isinstance(norm, mcolors.Normalize))
if aspect is None:
aspect = rcParams['image.aspect']
axes.set_aspect(aspect)
im = ModestImage(axes, cmap=cmap, norm=norm, interpolation=interpolation,
origin=origin, extent=extent, filternorm=filternorm,
filterrad=filterrad, resample=resample, **kwargs)
im.set_data(X)
im.set_alpha(alpha)
axes._set_artist_props(im)
if im.get_clip_path() is None:
# image does not already have clipping set, clip to axes patch
im.set_clip_path(axes.patch)
# if norm is None and shape is None:
# im.set_clim(vmin, vmax)
if vmin is not None or vmax is not None:
im.set_clim(vmin, vmax)
# elif norm is None:
# im.autoscale_None()
im.set_url(url)
# update ax.dataLim, and, if autoscaling, set viewLim
# to tightly fit the image, regardless of dataLim.
if extent is not None:
im.set_extent(extent)
axes.images.append(im)
def remove(h):
axes.images.remove(h)
im._remove_method = remove
return im
def extract_matched_slices(axes=None, shape=None, extent=None,
transform=IDENTITY_TRANSFORM):
"""Determine the slice parameters to use, matched to the screen.
:param ax: Axes object to query. It's extent and pixel size
determine the slice parameters
:param shape: Tuple of the full image shape to slice into. Upper
boundaries for slices will be cropped to fit within
this shape.
:rtype: tulpe of x0, x1, sx, y0, y1, sy
Indexing the full resolution array as array[y0:y1:sy, x0:x1:sx] returns
a view well-matched to the axes' resolution and extent
"""
# Find extent in display pixels (this gives the resolution we need
# to sample the array to)
ext = (axes.transAxes.transform([(1, 1)]) - axes.transAxes.transform([(0, 0)]))[0]
# Find the extent of the axes in 'world' coordinates
xlim, ylim = axes.get_xlim(), axes.get_ylim()
# Transform the limits to pixel coordinates
ind0 = transform.transform([min(xlim), min(ylim)])
ind1 = transform.transform([max(xlim), max(ylim)])
def _clip(val, lo, hi):
return int(max(min(val, hi), lo))
# Determine the range of pixels to extract from the array, including a 5
# pixel margin all around. We ensure that the shape of the resulting array
# will always be at least (1, 1) even if there is really no overlap, to
# avoid issues.
y0 = _clip(ind0[1] - 5, 0, shape[0] - 1)
y1 = _clip(ind1[1] + 5, 1, shape[0])
x0 = _clip(ind0[0] - 5, 0, shape[1] - 1)
x1 = _clip(ind1[0] + 5, 1, shape[1])
# Determine the strides that can be used when extracting the array
sy = int(max(1, min((y1 - y0) / 5., np.ceil(abs((ind1[1] - ind0[1]) / ext[1])))))
sx = int(max(1, min((x1 - x0) / 5., np.ceil(abs((ind1[0] - ind0[0]) / ext[0])))))
return x0, x1, sx, y0, y1, sy
if __name__ == "__main__":
main()
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/ 0000755 0001750 0001750 00000000000 13752535025 021552 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/gui.py 0000644 0001750 0001750 00000032145 13557050406 022713 0 ustar noahfx noahfx from __future__ import print_function
import os
import math
import warnings
import numpy as np
from matplotlib.collections import LineCollection
from matplotlib.transforms import Bbox
from matplotlib.patches import Polygon
from .geometry.path import Path, get_endpoints
from . import extract_pv_slice
def distance(x1, y1, x2, y2, x3, y3):
"""
Find the shortest distance between a point (x3, y3) and the line passing
through the points (x1, y1) and (x2, y2).
"""
px = x2-x1
py = y2-y1
something = px * px + py * py
u = ((x3 - x1) * px + (y3 - y1) * py) / float(something)
x = x1 + u * px
y = y1 + u * py
dx = x - x3
dy = y - y3
dist = math.sqrt(dx*dx + dy*dy)
return dist
class MovableSliceBox(object):
def __init__(self, box, callback):
self.box = box
self.press = None
self.background = None
self.point_counter = 0
self.callback = callback
self.mode = 0
self.show_poly = False
self.cidpress = self.box.figure.canvas.mpl_connect('draw_event', self.draw_slicer)
def connect(self):
self.cidpress = self.box.figure.canvas.mpl_connect('key_press_event', self.key_press)
self.cidpress = self.box.figure.canvas.mpl_connect('button_press_event', self.on_press)
self.cidmotion = self.box.figure.canvas.mpl_connect('motion_notify_event', self.on_motion)
def draw_slicer(self, event):
axes = self.box.axes
canvas = self.box.figure.canvas
self.box.axes.draw_artist(self.box)
if self.show_poly:
path = Path(zip(self.box.x, self.box.y))
path.width = self.box.width
patches = path.to_patches(1, ec='green', fc='none',
transform=self.box.axes.transData,
clip_on=True, clip_box=self.box.axes.bbox)
for patch in patches:
self.box.axes.draw_artist(patch)
def on_press(self, event):
if self.box.figure.canvas.toolbar.mode != '':
return
if event.inaxes != self.box.axes:
return
if self.mode == 1:
self.callback(self.box)
self.mode += 1
return
if self.mode == 2:
self.box.x = []
self.box.y = []
self.mode = 0
self.point_counter = 0
self.press = event.xdata, event.ydata
self.point_counter += 1
axes = self.box.axes
canvas = self.box.figure.canvas
if self.point_counter == 1: # first point
self.box.x.append(event.xdata)
self.box.x.append(event.xdata)
self.box.y.append(event.ydata)
self.box.y.append(event.ydata)
self.box.width = 0.
self.box.set_animated(True)
canvas.draw()
self.background = canvas.copy_from_bbox(self.box.axes.bbox)
elif self.mode == 0:
self.box.x.append(event.xdata)
self.box.y.append(event.ydata)
self.box._update_segments()
# now redraw just the lineangle
axes.draw_artist(self.box)
def key_press(self, event):
if self.box.figure.canvas.toolbar.mode != '':
return
if event.key == 'enter' and self.mode == 0:
self.mode += 1
self.box.x = self.box.x[:-1]
self.box.y = self.box.y[:-1]
if event.key == 'y' and self.mode == 2:
self.show_poly = not self.show_poly
self.draw_slicer(event)
self.box.figure.canvas.draw()
def on_motion(self, event):
if self.box.figure.canvas.toolbar.mode != '':
return
if self.point_counter == 0:
return
if self.mode == 2:
return
canvas = self.box.figure.canvas
axes = self.box.axes
canvas.restore_region(self.background)
if event.inaxes != axes:
return
if self.mode == 0:
self.box.x[-1] = event.xdata
self.box.y[-1] = event.ydata
elif self.mode == 1:
self.box.width = distance(self.box.x[-2], self.box.y[-2], self.box.x[-1], self.box.y[-1], event.xdata, event.ydata) * 2
self.box._update_segments()
# redraw just the current lineangle
axes.draw_artist(self.box)
canvas.blit()
def disconnect(self):
self.box.figure.canvas.mpl_disconnect(self.cidpress)
self.box.figure.canvas.mpl_disconnect(self.cidmotion)
class SliceCurve(LineCollection):
def __init__(self, x=[], y=[], width=None, **kwargs):
super(SliceCurve, self).__init__([], **kwargs)
self.x = x
self.y = y
self.width = width
self._update_segments()
def _update_segments(self):
if not self.x or self.width is None or len(self.x) < 2:
return
# Find central line
line = zip(self.x, self.y)
if self.width:
x1, y1, x2, y2 = get_endpoints(self.x, self.y, self.width)
# Find bounding rectangle
rect = zip(np.hstack([x1,x2[::-1], x1[0]]),
np.hstack([y1,y2[::-1], y1[0]]))
self.set_segments([list(line), list(rect)])
self.set_linestyles(['solid', 'dashed'])
self.set_linewidths([2, 1])
else:
self.set_segments([list(line)])
self.set_linestyles(['solid'])
self.set_linewidths([2,])
def unitless(x):
if hasattr(x, 'unit'):
return x.value
else:
return x
class PVSlicer(object):
def __init__(self, filename_or_cube, backend=None, clim=None, cmap=None):
try:
from spectral_cube import SpectralCube
if isinstance(filename_or_cube, SpectralCube):
cube = filename_or_cube
else:
cube = SpectralCube.read(filename_or_cube, format='fits')
self.cube = cube
self.array = self.cube
self.shape = cube.shape
except ImportError:
warnings.warn("spectral_cube package is not available - using astropy.io.fits directly")
from astropy.io import fits
self.array = fits.getdata(filename_or_cube)
self.shape = array.shape
self.ok_mask = np.isfinite(self.array)
if self.array.ndim != 3:
raise ValueError("dataset does not have 3 dimensions (install the spectral_cube package to avoid this error)")
import matplotlib as mpl
# We reset the rc parameters to the default values to make sure we use
# the default interactive backend and to make sure that the UI is
# consistent.
mpl.rcdefaults()
if backend is not None:
mpl.use(backend)
import matplotlib.pyplot as plt
self.fig = plt.figure(figsize=(8, 5))
self.backend = mpl.get_backend()
print("Using Matplotlib backend: {0}".format(self.backend))
self.cmap = cmap
self.ax1 = self.fig.add_axes([0.1, 0.1, 0.4, 0.7], aspect='equal', adjustable='datalim')
if clim is None:
warnings.warn("clim not defined and will be determined from the data")
# To work with large arrays, sub-sample the data
# (but don't do it for small arrays)
n1 = int(np.round(max(self.shape[0] / 10, 1)))
n2 = int(np.round(max(self.shape[1] / 10, 1)))
n3 = int(np.round(max(self.shape[2] / 10, 1)))
if hasattr(self,'cube'):
sub_cube = self.cube[::n1,::n2,::n3]
cmin = sub_cube.min().value
cmax = sub_cube.max().value
else:
sub_array = self.array[::n1,::n2,::n3]
sub_mask = self.ok_mask[::n1,::n2,::n3]
cmin = sub_array[sub_mask].min()
cmax = sub_array[sub_mask].max()
crange = cmax - cmin
self._clim = (cmin - crange, cmax + crange)
else:
self._clim = clim
self.slice = int(round(self.shape[0] / 2.))
from matplotlib.widgets import Slider
self.slice_slider_ax = self.fig.add_axes([0.1, 0.95, 0.4, 0.03])
self.slice_slider_ax.set_xticklabels("")
self.slice_slider_ax.set_yticklabels("")
self.slice_slider = Slider(self.slice_slider_ax, "3-d slice", 0, self.shape[0]-1, valinit=self.slice, valfmt="%i")
self.slice_slider.on_changed(self.update_slice)
self.slice_slider.drawon = False
self.image = self.ax1.imshow(unitless(self.array[self.slice, :,:]),
origin='lower', interpolation='nearest',
vmin=self._clim[0], vmax=self._clim[1],
cmap=self.cmap)
self.vmin_slider_ax = self.fig.add_axes([0.1, 0.90, 0.4, 0.03])
self.vmin_slider_ax.set_xticklabels("")
self.vmin_slider_ax.set_yticklabels("")
self.vmin_slider = Slider(self.vmin_slider_ax, "vmin", self._clim[0], self._clim[1], valinit=self._clim[0])
self.vmin_slider.on_changed(self.update_vmin)
self.vmin_slider.drawon = False
self.vmax_slider_ax = self.fig.add_axes([0.1, 0.85, 0.4, 0.03])
self.vmax_slider_ax.set_xticklabels("")
self.vmax_slider_ax.set_yticklabels("")
self.vmax_slider = Slider(self.vmax_slider_ax, "vmax", self._clim[0], self._clim[1], valinit=self._clim[1])
self.vmax_slider.on_changed(self.update_vmax)
self.vmax_slider.drawon = False
self.grid1 = None
self.grid2 = None
self.grid3 = None
self.ax2 = self.fig.add_axes([0.55, 0.1, 0.4, 0.7])
# Add slicing box
self.box = SliceCurve(colors=(0.8, 0.0, 0.0))
self.ax1.add_collection(self.box)
self.movable = MovableSliceBox(self.box, callback=self.update_pv_slice)
self.movable.connect()
# Add save button
from matplotlib.widgets import Button
self.save_button_ax = self.fig.add_axes([0.65, 0.90, 0.20, 0.05])
self.save_button = Button(self.save_button_ax, 'Save slice to FITS')
self.save_button.on_clicked(self.save_fits)
self.file_status_text = self.fig.text(0.75, 0.875, "", ha='center', va='center')
self.set_file_status(None)
self.set_file_status(None)
self.pv_slice = None
self.cidpress = self.fig.canvas.mpl_connect('button_press_event', self.click)
def set_file_status(self, status, filename=None):
if status == 'instructions':
self.file_status_text.set_text('Please enter filename in terminal')
self.file_status_text.set_color('red')
elif status == 'saved':
self.file_status_text.set_text('File successfully saved to {0}'.format(filename))
self.file_status_text.set_color('green')
else:
self.file_status_text.set_text('')
self.file_status_text.set_color('black')
self.fig.canvas.draw()
def click(self, event):
if event.inaxes != self.ax2:
return
self.slice_slider.set_val(event.ydata)
def save_fits(self, *args, **kwargs):
if self.pv_slice is None:
return
# When using Qt, we need to use a proper Qt save dialog since input()
# does not play nicely with the Qt event loop.
if self.backend.lower().startswith('qt'):
from qtpy.compat import getsavefilename
plot_name, _ = getsavefilename()
if not plot_name:
return
else:
self.set_file_status('instructions')
print("Enter filename: ", end='')
plot_name = str(input())
from astropy.io import fits
self.pv_slice.writeto(plot_name, overwrite=True)
print("Saved file to: ", plot_name)
self.set_file_status('saved', filename=plot_name)
def update_pv_slice(self, box):
path = Path(zip(box.x, box.y))
path.width = box.width
self.pv_slice = extract_pv_slice(self.array, path)
self.ax2.cla()
self.ax2.imshow(self.pv_slice.data, origin='lower', aspect='auto',
interpolation='nearest', cmap=self.cmap)
self.fig.canvas.draw()
def show(self, block=True):
import matplotlib.pyplot as plt
plt.show(block=block)
def update_slice(self, pos=None):
if self.array.ndim == 2:
self.image.set_array(unitless(self.array))
else:
self.slice = int(round(pos))
self.image.set_array(unitless(self.array[self.slice, :, :]))
self.fig.canvas.draw()
def update_vmin(self, vmin):
if vmin > self._clim[1]:
self._clim = (self._clim[1], self._clim[1])
else:
self._clim = (vmin, self._clim[1])
self.image.set_clim(*self._clim)
self.fig.canvas.draw()
def update_vmax(self, vmax):
if vmax < self._clim[0]:
self._clim = (self._clim[0], self._clim[0])
else:
self._clim = (self._clim[0], vmax)
self.image.set_clim(*self._clim)
self.fig.canvas.draw()
def close(self):
import matplotlib.pyplot as plt
plt.close(self.fig)
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/LICENSE 0000644 0001750 0001750 00000002725 13503376220 022557 0 ustar noahfx noahfx Copyright (c) 2014, pvextractor developers
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/__init__.py 0000644 0001750 0001750 00000000355 13503376220 023660 0 ustar noahfx noahfx # Licensed under a 3-clause BSD style license - see LICENSE.rst
from . import utils
from .pvextractor import extract_pv_slice
from .utils.wcs_slicing import slice_wcs
from .geometry import Path
from .pvregions import paths_from_regfile
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/ 0000755 0001750 0001750 00000000000 13752535025 023405 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/tests/ 0000755 0001750 0001750 00000000000 13752535025 024547 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/tests/__init__.py 0000644 0001750 0001750 00000000000 13503376220 026640 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/path.py 0000644 0001750 0001750 00000017732 13557050406 024723 0 ustar noahfx noahfx from __future__ import print_function
import sys
import numpy as np
from astropy.wcs import WCSSUB_CELESTIAL
from astropy.wcs.utils import wcs_to_celestial_frame
from astropy.coordinates import BaseCoordinateFrame
from ..utils.wcs_utils import get_spatial_scale
class Polygon(object):
def __init__(self, x, y):
self.x = x
self.y = y
def segment_angles(x, y):
dx = np.diff(x)
dy = np.diff(y)
d = np.hypot(dx, dy)
cos_theta = (-dx[:-1] * dx[1:] - dy[:-1] * dy[1:]) / (d[:-1] * d[1:])
cos_theta = np.clip(cos_theta, -1., 1.)
sin_theta = (-dx[:-1] * dy[1:] + dy[:-1] * dx[1:]) / (d[:-1] * d[1:])
sin_theta = np.clip(sin_theta, -1., 1.)
theta = np.arctan2(sin_theta, cos_theta)
theta[0] = np.pi
theta[-1] = np.pi
return theta
def get_endpoints(x, y, width):
# Pad with same values at ends, to find slope of perpendicular end
# lines.
try:
xp = np.pad(x, 1, mode='edge')
yp = np.pad(y, 1, mode='edge')
except AttributeError: # Numpy < 1.7
xp = np.hstack([x[0], x, x[-1]])
yp = np.hstack([y[0], y, y[-1]])
dx = np.diff(xp)
dy = np.diff(yp)
alpha = segment_angles(xp, yp) / 2.
beta = np.arctan2(dy, dx)[:-1]
beta[0] = beta[1]
gamma = -(np.pi - alpha - beta)
dx = np.cos(gamma)
dy = np.sin(gamma)
angles = segment_angles(xp, yp) / 2.
# Find points offset from main curve, on bisecting lines
x1 = x - dx * width * 0.5 / np.sin(angles)
x2 = x + dx * width * 0.5 / np.sin(angles)
y1 = y - dy * width * 0.5 / np.sin(angles)
y2 = y + dy * width * 0.5 / np.sin(angles)
return x1, y1, x2, y2
class Path(object):
"""
A curved path that may have a non-zero width and is used to extract
slices from cubes.
Parameters
----------
xy_or_coords : list or Astropy coordinates
The points defining the path. This can be passed as a list of (x, y)
tuples, which is interpreted as being pixel positions, or it can be
an Astropy coordinate object containing an array of 2 or more
coordinates.
width : None or float or :class:`~astropy.units.Quantity`
The width of the path. If ``coords`` is passed as a list of pixel
positions, the width should be given (if passed) as a floating-point
value in pixels. If ``coords`` is a coordinate object, the width
should be passed as a :class:`~astropy.units.Quantity` instance with
units of angle. If None, interpolation is used at the position of the
path.
"""
def __init__(self, xy_or_coords, width=None):
if isinstance(xy_or_coords, list):
self._xy = xy_or_coords
self._coords = None
elif sys.version_info[0] > 2 and isinstance(xy_or_coords, zip):
self._xy = list(xy_or_coords)
self._coords = None
else:
self._xy = None
self._coords = xy_or_coords
self.width = width
def add_point(self, xy_or_coord):
"""
Add a point to the path
Parameters
----------
xy_or_coord : tuple or Astropy coordinate
A tuple (x, y) containing the coordinates of the point to add (if
the path is defined in pixel space), or an Astropy coordinate
object (if it is defined in world coordinates).
"""
if self._xy is not None:
if isinstance(xy_or_coord, tuple):
self._xy.append(xy_or_coord)
else:
raise TypeError("Path is defined as a list of pixel "
"coordinates, so `xy_or_coord` should be "
"a tuple of `(x,y)` pixel coordinates.")
else:
if isinstance(xy_or_coord, BaseCoordinateFrame):
raise NotImplementedError("Cannot yet append world coordinates to path")
else:
raise TypeError("Path is defined in world coordinates, "
"so `xy_or_coord` should be an Astropy "
"coordinate object.")
def get_xy(self, wcs=None):
"""
Return the pixel coordinates of the path.
If the path is defined in world coordinates, the appropriate WCS
transformation should be passed.
Parameters
----------
wcs : :class:`~astropy.wcs.WCS`
The WCS transformation to assume in order to transform the path
to pixel coordinates.
"""
if self._xy is not None:
return self._xy
else:
if wcs is None:
raise ValueError("`wcs` is needed in order to compute "
"the pixel coordinates")
else:
# Extract the celestial component of the WCS
wcs_sky = wcs.sub([WCSSUB_CELESTIAL])
# Find the astropy name for the coordinates
celestial_system = wcs_to_celestial_frame(wcs_sky)
world_coords = self._coords.transform_to(celestial_system)
xw, yw = world_coords.spherical.lon.degree, world_coords.spherical.lat.degree
return list(zip(*wcs_sky.wcs_world2pix(xw, yw, 0)))
def sample_points_edges(self, spacing, wcs=None):
x, y = zip(*self.get_xy(wcs=wcs))
# Find the distance interval between all pairs of points
dx = np.diff(x)
dy = np.diff(y)
dd = np.hypot(dx, dy)
# Find the total displacement along the broken curve
d = np.hstack([0., np.cumsum(dd)])
# Figure out the number of points to sample, and stop short of the
# last point.
n_points = int(np.floor(d[-1] / spacing))
if n_points == 0:
raise ValueError("Path is shorter than spacing")
d_sampled = np.linspace(0., n_points * spacing, n_points + 1)
x_sampled = np.interp(d_sampled, d, x)
y_sampled = np.interp(d_sampled, d, y)
return d_sampled, x_sampled, y_sampled
def sample_points(self, spacing, wcs=None):
d_sampled, x_sampled, y_sampled = self.sample_points_edges(spacing, wcs=wcs)
x_sampled = 0.5 * (x_sampled[:-1] + x_sampled[1:])
y_sampled = 0.5 * (y_sampled[:-1] + y_sampled[1:])
return x_sampled, y_sampled
def sample_polygons(self, spacing, wcs=None):
x, y = zip(*self.get_xy(wcs=wcs))
d_sampled, x_sampled, y_sampled = self.sample_points_edges(spacing, wcs=wcs)
# Find the distance interval between all pairs of points
dx = np.diff(x)
dy = np.diff(y)
dd = np.hypot(dx, dy)
# Normalize to find unit vectors
dx = dx / dd
dy = dy / dd
# Find the total displacement along the broken curve
d = np.hstack([0., np.cumsum(dd)])
interval = np.searchsorted(d, d_sampled) - 1
interval[0] = 0
dx = dx[interval]
dy = dy[interval]
polygons = []
x_beg = x_sampled
x_end = x_sampled + dx * spacing
y_beg = y_sampled
y_end = y_sampled + dy * spacing
if hasattr(self.width, 'unit'):
scale = get_spatial_scale(wcs)
width = (self.width / scale).decompose().value
else:
width = self.width
x1 = x_beg - dy * width * 0.5
y1 = y_beg + dx * width * 0.5
x2 = x_end - dy * width * 0.5
y2 = y_end + dx * width * 0.5
x3 = x_end + dy * width * 0.5
y3 = y_end - dx * width * 0.5
x4 = x_beg + dy * width * 0.5
y4 = y_beg - dx * width * 0.5
for i in range(len(x_sampled) - 1):
p = Polygon([x1[i], x2[i], x3[i], x4[i]], [y1[i], y2[i], y3[i], y4[i]])
polygons.append(p)
return polygons
def to_patches(self, spacing, wcs=None, **kwargs):
from matplotlib.patches import Polygon as MPLPolygon
patches = []
for poly in self.sample_polygons(spacing, wcs=wcs):
patches.append(MPLPolygon(list(zip(poly.x, poly.y)), **kwargs))
return patches
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/poly_slices.py 0000644 0001750 0001750 00000003742 13557050406 026310 0 ustar noahfx noahfx from __future__ import print_function
import numpy as np
from astropy.utils.console import ProgressBar
from .polygon import square_polygon_overlap_area
def extract_poly_slice(cube, polygons, return_area=False):
"""
Extract the values of polygonal chunks from a data cube
Parameters
----------
cube : np.ndarray
polygons :
return_area : bool
If set, return the area of each polygon and the sum over that area.
Otherwise, return the mean.
"""
nx = len(polygons)
nz = cube.shape[0]
total_slice = np.zeros((nz, nx))
total_area = np.zeros((nz, nx))
p = ProgressBar(len(polygons))
for i, polygon in enumerate(polygons):
p.update()
# Find bounding box
bbxmin = int(round(np.min(polygon.x))-1)
bbxmax = int(round(np.max(polygon.x))+2)
bbymin = int(round(np.min(polygon.y))-1)
bbymax = int(round(np.max(polygon.y))+2)
# Clip to cube box
bbxmin = max(bbxmin, 0)
bbxmax = min(bbxmax, cube.shape[2])
bbymin = max(bbymin, 0)
bbymax = min(bbymax, cube.shape[1])
# Loop through pixels that might overlap
for xmin in np.arange(bbxmin, bbxmax):
for ymin in np.arange(bbymin, bbymax):
area = square_polygon_overlap_area(xmin-0.5, xmin+0.5,
ymin-0.5, ymin+0.5,
polygon.x, polygon.y)
if area > 0:
dataslice = cube[:, ymin, xmin]
good_values = np.isfinite(dataslice)
if np.any(good_values):
total_slice[good_values, i] += dataslice[good_values] * area
total_area[good_values, i] += area
total_slice[total_area == 0.] = np.nan
if return_area:
return total_slice, total_area
total_slice[total_area > 0.] /= total_area[total_area > 0.]
print("")
return total_slice
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/__init__.py 0000644 0001750 0001750 00000000135 13557050406 025513 0 ustar noahfx noahfx from .slices import extract_slice
from .path import Path
from .helpers import PathFromCenter
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/helpers.py 0000644 0001750 0001750 00000007757 13557050406 025437 0 ustar noahfx noahfx import numpy as np
from astropy import units as u
from astropy.coordinates import (SkyCoord, BaseCoordinateFrame,
UnitSphericalRepresentation,
CartesianRepresentation)
from .path import Path
class PathFromCenter(Path):
"""
A simple path defined by a center, length, and position angle.
Parameters
----------
center : `~astropy.coordinates.SkyCoord`
The center of the path
length : `~astropy.units.Quantity`
The length of the path in angular units
angle : `~astropy.units.Quantity`
The position angle of the path, counter-clockwise
sample : int
How many points to sample along the path. By default, this is 2 (the
two end points. For small fields of view, this will be a good
approximation to the path, but for larger fields of view, where
spherical distortions become important, this should be increased to
provide a smooth path.
width : None or float or :class:`~astropy.units.Quantity`
The width of the path. If ``coords`` is passed as a list of pixel
positions, the width should be given (if passed) as a floating-point
value in pixels. If ``coords`` is a coordinate object, the width
should be passed as a :class:`~astropy.units.Quantity` instance with
units of angle. If None, interpolation is used at the position of the
path.
Notes
-----
The orientation of the final path will be such that for a position angle of
zero, the path goes from South to North. For a position angle of 90
degrees, the path will go from West to East.
"""
def __init__(self, center, length=None, angle=None, sample=2, width=None):
# Check input types
if not isinstance(center, (SkyCoord, BaseCoordinateFrame)):
raise TypeError("The central position should be given as a SkyCoord object")
if not isinstance(length, u.Quantity) or not length.unit.is_equivalent(u.deg):
raise TypeError("The length should be given as an angular Quantity")
if not isinstance(angle, u.Quantity) or not angle.unit.is_equivalent(u.deg):
raise TypeError("The angle should be given as an angular Quantity")
# We set up the path by adding and removing half the length along the
# declination axis, then rotate the resulting two points around the
# center.
# Convert the central position to cartesian coordinates
c1, c2, c3 = center.cartesian.xyz.value
# Find the end points of the path
clon, clat = center.spherical.lon, center.spherical.lat
try:
plat = clat + np.linspace(-length * 0.5, length * 0.5, sample)
except ValueError: # Numpy 1.10+
plat = clat + np.linspace(-length.value * 0.5, length.value * 0.5, sample) * length.unit
x, y, z = UnitSphericalRepresentation(clon, plat).to_cartesian().xyz.value
# Rotate around central point
# Because longitude increases to the left, we have to take -angle
angle = -angle
# We rotate (x,y,z) around (c1,c2,c3) by making use of the following
# equations:
#
# x' = x cos a + (1 - cos a)(c1c1x + c1c2y + c1c3z) + (c2z - c3y)sin a
# y' = y cos a + (1 - cos a)(c2c1x + c2c2y + c2c3z) + (c3x - c1z)sin a
# z' = z cos a + (1 - cos a)(c3c1x + c3c2y + c3c3z) + (c1y - c2x)sin a
#
# Source: https://www.uwgb.edu/dutchs/MATHALGO/sphere0.htm
cosa = np.cos(angle)
sina = np.sin(angle)
xd = x * cosa + (1 - cosa) * (c1*c1*x + c1*c2*y + c1*c3*z) + (c2 * z - c3 * y) * sina
yd = y * cosa + (1 - cosa) * (c2*c1*x + c2*c2*y + c2*c3*z) + (c3 * x - c1 * z) * sina
zd = z * cosa + (1 - cosa) * (c3*c1*x + c3*c2*y + c3*c3*z) + (c1 * y - c2 * x) * sina
# Construct representations
points = center.realize_frame(CartesianRepresentation(x=xd, y=yd, z=zd))
super(PathFromCenter, self).__init__(points, width=width)
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/polygon.py 0000644 0001750 0001750 00000001666 13503376220 025451 0 ustar noahfx noahfx """
This module implements polygon-square intersection using matplotlib. It is
twice as fast as Shapely for this specific case and avoids requiring another
dependency.
"""
import numpy as np
from matplotlib.path import Path
from matplotlib.transforms import Bbox
def square_polygon_intersection(xmin, xmax, ymin, ymax, x, y):
poly = Path(list(zip(x, y)))
box = Bbox([[xmin, ymin], [xmax, ymax]])
try:
clipped_poly = poly.clip_to_bbox(box)
except ValueError:
return [], []
else:
return clipped_poly.vertices[:, 0], clipped_poly.vertices[:, 1]
def polygon_area(x, y):
x1 = x
x2 = np.roll(x, -1)
y1 = y
y2 = np.roll(y, -1)
return abs(0.5 * np.sum(x1 * y2 - x2 * y1))
def square_polygon_overlap_area(xmin, xmax, ymin, ymax, x, y):
x, y = square_polygon_intersection(xmin, xmax, ymin, ymax, x, y)
if len(x) == 0:
return 0.
else:
return polygon_area(x, y)
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/slices.py 0000644 0001750 0001750 00000002475 13503376220 025243 0 ustar noahfx noahfx import numpy as np
from .line_slices import extract_line_slice
from .poly_slices import extract_poly_slice
def extract_slice(cube, path, spacing=1.0, order=3, respect_nan=True,
wcs=None):
"""
Given an array with shape (z, y, x), extract a (z, n) slice from a path
with ``n`` segments.
All units are in *pixels*
.. note:: If there are NaNs in the cube, they will be treated as zeros when
using spline interpolation.
Parameters
----------
path : `Path`
The path along which to define the slice
spacing : float
The position resolution in the final slice
order : int, optional
Spline interpolation order when using line paths. Does not have any
effect for polygon paths.
respect_nan : bool, optional
If set to `False`, NaN values are changed to zero before computing
the slices.
Returns
-------
slice : `numpy.ndarray`
The slice
"""
if not respect_nan:
cube = np.nan_to_num(cube)
if path.width is None:
x, y = path.sample_points(spacing=spacing, wcs=wcs)
slice = extract_line_slice(cube, x, y, order=order)
else:
polygons = path.sample_polygons(spacing=spacing, wcs=wcs)
slice = extract_poly_slice(cube, polygons)
return slice
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/geometry/line_slices.py 0000644 0001750 0001750 00000004046 13605360531 026247 0 ustar noahfx noahfx from __future__ import print_function
import numpy as np
from scipy.ndimage import map_coordinates
def extract_line_slice(cube, x, y, order=3, respect_nan=True):
"""
Given an array with shape (z, y, x), extract a (z, n) slice by
interpolating at n (x, y) points.
All units are in *pixels*.
.. note:: If there are NaNs in the cube, they will be treated as zeros when
using spline interpolation.
Parameters
----------
cube : `~numpy.ndarray`
The data cube to extract the slice from
curve : list or tuple
A list or tuple of (x, y) pairs, with minimum length 2
order : int, optional
Spline interpolation order. Set to ``0`` for nearest-neighbor
interpolation.
Returns
-------
slice : `numpy.ndarray`
The (z, d) slice
"""
if order == 0:
total_slice = np.zeros([cube.shape[0], len(x)]) + np.nan
x = np.round(x)
y = np.round(y)
ok = (x >= 0) & (y >= 0) & (x < cube.shape[2]) & (y < cube.shape[1])
total_slice[:,ok] = cube[:, y[ok].astype(int), x[ok].astype(int)]
elif order > 0 and order == int(order):
nx = len(x)
nz = cube.shape[0]
zi = np.outer(np.arange(nz, dtype=int), np.ones(nx))
xi = np.outer(np.ones(nz), x)
yi = np.outer(np.ones(nz), y)
if np.any(np.isnan(cube)):
# map_coordinates does not deal well with NaN values so we have
# to remove the NaN values then re-mask the final slice.
total_slice = map_coordinates(np.nan_to_num(cube), [zi,yi,xi],
order=order, cval=np.nan)
slice_bad = map_coordinates(np.nan_to_num(np.isnan(cube).astype(int)),
[zi,yi,xi], order=order)
total_slice[np.nonzero(slice_bad)] = np.nan
else:
total_slice = map_coordinates(cube, [zi,yi,xi], order=order, cval=np.nan)
else:
raise TypeError("order should be a positive integer")
return total_slice
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/pvextractor.py 0000644 0001750 0001750 00000010501 13605357235 024504 0 ustar noahfx noahfx from __future__ import print_function
import numpy as np
import six
import warnings
from astropy import units as u
from astropy.io.fits import PrimaryHDU, ImageHDU, Header
from .utils.wcs_utils import get_spatial_scale, sanitize_wcs
from .geometry import extract_slice
from .geometry import path as paths
from .utils.wcs_slicing import slice_wcs
def extract_pv_slice(cube, path, wcs=None, spacing=1.0, order=3,
respect_nan=True):
"""
Given a position-position-velocity cube with dimensions (nv, ny, nx), and
a path, extract a position-velocity slice.
Alternative implementations:
gipsy::sliceview
karma::kpvslice
casaviewer::slice
Parameters
----------
cube : :class:`~numpy.ndarray` or :class:`~spectral_cube.SpectralCube` or str or HDU
The cube to extract a slice from. If this is a plain
:class:`~numpy.ndarray` instance, the WCS information can optionally
be specified with the ``wcs`` parameter. If a string, it should be
the name of a file containing a spectral cube.
path : `Path` or list of 2-tuples
The path along which to define the position-velocity slice. The path
can contain coordinates defined in pixel or world coordinates.
wcs : :class:`~astropy.wcs.WCS`, optional
The WCS information to use for the cube. This should only be
specified if the ``cube`` parameter is a plain
:class:`~numpy.ndarray` instance.
spacing : float
The position resolution in the final position-velocity slice. This
can be given in pixel coordinates or as a
:class:`~astropy.units.Quantity` instance with angle units.
order : int, optional
Spline interpolation order when using paths with zero width. Does not
have any effect for paths with a non-zero width.
respect_nan : bool, optional
If set to `False`, NaN values are changed to zero before computing
the slices. If set to `True`, in the case of line paths a second
computation is performed to ignore the NaN value while interpolating,
and set the output values of NaNs to NaN.
Returns
-------
slice : `PrimaryHDU`
The position-velocity slice, as a FITS HDU object
"""
if isinstance(cube, (str, ImageHDU, PrimaryHDU)):
try:
from spectral_cube import SpectralCube
cube = SpectralCube.read(cube)
except ImportError:
raise ImportError("spectral_cube package required for working "
"with fits data. Install spectral_cube or "
"use NumPy arrays")
if _is_spectral_cube(cube):
wcs = cube.wcs
# The fits HEADER will preserve the UNIT, but pvextractor does not care
# what the flux units are
cube = cube.filled_data[...].value
if wcs is not None:
wcs = sanitize_wcs(wcs)
if not isinstance(cube, np.ndarray) or wcs is not None:
scale = get_spatial_scale(wcs)
if isinstance(spacing, u.Quantity):
pixel_spacing = (spacing / scale).decompose()
world_spacing = spacing
else:
pixel_spacing = spacing
world_spacing = spacing * scale
else:
if isinstance(spacing, u.Quantity):
raise TypeError("No WCS has been specified, so spacing should be given in pixels")
else:
pixel_spacing = spacing
world_spacing = None
# Allow path to be passed in as list of 2-tuples
if not isinstance(path, paths.Path):
path = paths.Path(path)
pv_slice = extract_slice(cube, path, wcs=wcs, spacing=pixel_spacing,
order=order, respect_nan=respect_nan)
# Generate output header
if wcs is None:
header = Header()
else:
header = slice_wcs(wcs, spatial_scale=world_spacing).to_header()
# TODO: write path to BinTableHDU
return PrimaryHDU(data=pv_slice, header=header)
def _is_spectral_cube(obj):
try:
from spectral_cube.spectral_cube import BaseSpectralCube
return isinstance(obj, BaseSpectralCube)
except ImportError:
if 'SpectralCube' in str(obj.__class__):
warnings.warn("Object appears to be a SpectralCube, but"
" the spectral_cube module could not be loaded")
return False
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/pvregions.py 0000644 0001750 0001750 00000012206 13557050406 024137 0 ustar noahfx noahfx import numpy as np
from .geometry import path
from astropy import coordinates
from astropy import units as u
import re
csystems = {'galactic':coordinates.Galactic,
'fk5':coordinates.FK5,
'fk4':coordinates.FK4,
'icrs':coordinates.ICRS}
cel_systems = ['fk5','fk4','icrs']
# ecliptic, detector, etc. not supported (because I don't know what they mean)
# (or with ecliptic, how to deal with them)
all_systems = cel_systems+['galactic','image','physical']
class SimpleRegion(object):
def __init__(self, coord_list, coord_format, name):
self.name = name
self.coord_format = coord_format
self.coord_list = coord_list
def __repr__(self):
return "Region: {0}, {1}, {2}".format(self.name, self.coord_list,
self.coord_format)
valid_regions = ['line', 'segment', 'vector']
valid_region_re = [re.compile("^"+n) for n in valid_regions]
def simple_region_parser(regionstring, coord_format):
rs = regionstring.lstrip("# ")
rtype = None
for rt, rre in zip(valid_regions, valid_region_re):
if rre.search(rs):
rtype = rt
break
if rtype is None:
# not a usable region
return
coordre = re.compile("^[a-z]*\((.*)\)")
coord_list = coordre.findall(rs)
if len(coord_list) != 1:
raise ValueError("Invalid region")
coords = coord_list[0].split(",")
outcoords = []
for ii,cs in enumerate(coords):
if coord_format in csystems:
if ":" in cs:
# sexagesimal
if coord_format in cel_systems and ii % 2 == 0:
# odd, celestial = RA = hours
crd = coordinates.Angle(cs, unit=u.hour)
else:
crd = coordinates.Angle(cs, unit=u.deg)
else:
try:
# if it's a float, it's in degrees
crd = float(cs) * u.deg
except ValueError:
crd = coordinates.Angle(cs)
else:
# assume pixel units
crd = float(cs)
outcoords.append(crd)
reg = SimpleRegion(coord_list=outcoords, coord_format=coord_format,
name=rtype)
return reg
def load_regions_file(rfile):
with open(rfile,'r') as fh:
lines = fh.readlines()
return load_regions_stringlist(lines)
def load_regions_stringlist(lines):
coord_format = None
for line in lines:
if line.strip() in all_systems:
coord_format = line.strip()
break
if coord_format is None:
raise ValueError("No valid coordinate format found.")
regions_ = [simple_region_parser(line, coord_format) for line in lines]
regions = [r for r in regions_ if r is not None]
return regions
def line_to_path(region):
"""
Convert a line or segment to a path
"""
l,b = None,None
endpoints = []
for x in region.coord_list:
if l is None:
if hasattr(x,'unit'):
l = x.to(u.deg).value
else:
l = x
else:
if hasattr(x,'unit'):
b = x.to(u.deg).value
else:
b = x
if l is not None and b is not None:
if hasattr(b,'unit') or hasattr(l,'unit'):
raise TypeError("Can't work with a list of quantities")
endpoints.append((l,b))
l,b = None,None
else:
raise ValueError("unmatched l,b")
lbarr = np.array(endpoints)
C = csystems[region.coord_format](lbarr[:,0]*u.deg, lbarr[:,1]*u.deg)
# TODO: add widths for projection
p = path.Path(C)
return p
def vector_to_path(vector_region):
"""
Convert a vector region to a path
# vector(48.944348,-0.36432694,485.647",124.082) vector=1
"""
x,y = vector_region.coord_list[:2]
length = vector_region.coord_list[2]
angle = vector_region.coord_list[3]
C1 = csystems[vector_region.coord_format](x, y)
dx,dy = length * np.cos(angle), length * np.sin(angle)
# -dx because we're in the flippy coordsys
C2 = csystems[vector_region.coord_format](C1.spherical.lon - dx, C1.spherical.lat + dy)
C = csystems[vector_region.coord_format]([C1.spherical.lon.deg,C2.spherical.lon.deg]*u.deg,
[C1.spherical.lat.deg,C2.spherical.lat.deg]*u.deg)
p = path.Path(C)
return p
region_converters = {'line':line_to_path, 'segment':line_to_path,
'vector':vector_to_path}
def paths_from_regfile(regfile):
"""
Given a ds9 region file, extract pv diagrams for each:
group of points [NOT IMPLEMENTED]
panda [NOT IMPLEMENTED]
vector [NOT IMPLEMENTED]
segment [NOT IMPLEMENTED]
group of lines [NOT IMPLEMENTED]
"""
#import pyregion
#regions = pyregion.open(regfile)
regions = load_regions_file(regfile)
return paths_from_regions(regions)
def paths_from_regions(regions):
paths = [region_converters[r.name](r)
for r in regions
if r.name in region_converters]
return paths
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/utils/ 0000755 0001750 0001750 00000000000 13752535025 022712 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/utils/__init__.py 0000644 0001750 0001750 00000000000 13503376220 025003 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/utils/wcs_slicing.py 0000644 0001750 0001750 00000002346 13557050406 025573 0 ustar noahfx noahfx import numpy as np
from astropy import units as u
from astropy.wcs import WCS, WCSSUB_SPECTRAL
from .wcs_utils import get_spectral_scale
def slice_wcs(wcs, spatial_scale):
"""
Slice a WCS header for a spectral cube to a Position-Velocity WCS, with
ctype "OFFSET" for the spatial offset direction
Parameters
----------
wcs : :class:`~astropy.wcs.WCS`
The WCS of the spectral cube. This should already be sanitized and
have the spectral axis along the third dimension.
spatial_scale: :class:`~astropy.units.Quantity`
The spatial scale of the position axis
Returns
-------
wcs_slice :class:`~astropy.wcs.WCS`
The resulting WCS slice
"""
# Extract spectral slice
wcs_slice = wcs.sub([0, WCSSUB_SPECTRAL])
# Set spatial parameters
wcs_slice.wcs.crpix[0] = 1.
wcs_slice.wcs.cdelt[0] = spatial_scale.to(u.degree).value
wcs_slice.wcs.crval[0] = 0.
wcs_slice.wcs.ctype[0] = "OFFSET"
wcs_slice.wcs.cunit[0] = 'deg'
# Not clear why this is needed, but apparently sub with 0 sets pc[1,0] = 1,
# which is incorrect
try:
wcs_slice.wcs.pc[1,0] = wcs_slice.wcs.pc[0,1] = 0
except AttributeError:
pass
return wcs_slice
glueviz-1.0.1+dfsg.orig/glue/external/pvextractor/utils/wcs_utils.py 0000644 0001750 0001750 00000004627 13612622074 025305 0 ustar noahfx noahfx import numpy as np
from astropy import units as u
from astropy.wcs import WCSSUB_CELESTIAL, WCSSUB_SPECTRAL
def get_spatial_scale(wcs, assert_square=True):
# Code adapted from APLpy
wcs = wcs.sub([WCSSUB_CELESTIAL])
cdelt = np.matrix(wcs.wcs.get_cdelt())
pc = np.matrix(wcs.wcs.get_pc())
scale = np.array(cdelt * pc)
if assert_square:
try:
np.testing.assert_almost_equal(abs(cdelt[0,0]), abs(cdelt[0,1]))
np.testing.assert_almost_equal(abs(pc[0,0]), abs(pc[1,1]))
np.testing.assert_almost_equal(abs(scale[0,0]), abs(scale[0,1]))
except AssertionError:
raise ValueError("Non-square pixels. Please resample data.")
return abs(scale[0,0]) * u.Unit(wcs.wcs.cunit[0])
def get_spectral_scale(wcs):
# Code adapted from APLpy
wcs = wcs.sub([WCSSUB_SPECTRAL])
cdelt = np.matrix(wcs.wcs.get_cdelt())
pc = np.matrix(wcs.wcs.get_pc())
scale = np.array(cdelt * pc)
return abs(scale[0,0]) * u.Unit(wcs.wcs.cunit[0])
def sanitize_wcs(mywcs):
pc = np.matrix(mywcs.wcs.get_pc())
if (pc[:,2].sum() != pc[2,2] or pc[2,:].sum() != pc[2,2]):
raise ValueError("Non-independent 3rd axis.")
axtypes = mywcs.get_axis_types()
if ((axtypes[0]['coordinate_type'] != 'celestial' or
axtypes[1]['coordinate_type'] != 'celestial' or
axtypes[2]['coordinate_type'] != 'spectral')):
cunit3 = mywcs.wcs.cunit[2]
ctype3 = mywcs.wcs.ctype[2]
if cunit3 != '':
cunit3 = u.Unit(cunit3)
if cunit3.is_equivalent(u.m/u.s):
mywcs.wcs.ctype[2] = 'VELO'
elif cunit3.is_equivalent(u.Hz):
mywcs.wcs.ctype[2] = 'FREQ'
elif cunit3.is_equivalent(u.m):
mywcs.wcs.ctype[2] = 'WAVE'
else:
raise ValueError("Could not determine type of 3rd axis.")
elif ctype3 != '':
if 'VELO' in ctype3:
mywcs.wcs.ctype[2] = 'VELO'
elif 'FELO' in ctype3:
mywcs.wcs.ctype[2] = 'VELO-F2V'
elif 'FREQ' in ctype3:
mywcs.wcs.ctype[2] = 'FREQ'
elif 'WAVE' in ctype3:
mywcs.wcs.ctype[2] = 'WAVE'
else:
raise ValueError("Could not determine type of 3rd axis.")
else:
raise ValueError("Cube axes not in expected orientation: PPV")
return mywcs
glueviz-1.0.1+dfsg.orig/glue/__init__.py 0000644 0001750 0001750 00000002630 13527542473 017466 0 ustar noahfx noahfx # Set up configuration variables
__all__ = ['custom_viewer', 'qglue', 'test']
import os
import sys
from pkg_resources import get_distribution, DistributionNotFound
try:
__version__ = get_distribution('glue-core').version
except DistributionNotFound:
__version__ = 'undefined'
from ._mpl_backend import MatplotlibBackendSetter
sys.meta_path.append(MatplotlibBackendSetter())
from glue.viewers.custom.helper import custom_viewer
# Load user's configuration file
from .config import load_configuration
env = load_configuration()
from .qglue import qglue
from .main import load_plugins # noqa
def test(no_optional_skip=False):
from pytest import main
root = os.path.abspath(os.path.dirname(__file__))
args = [root, '-x']
if no_optional_skip:
args.append('--no-optional-skip')
return main(args=args)
from glue._settings_helpers import load_settings
load_settings()
# In PyQt 5.5+, PyQt overrides the default exception catching and fatally
# crashes the Qt application without printing out any details about the error.
# Below we revert the exception hook to the original Python one. Note that we
# can't just do sys.excepthook = sys.__excepthook__ otherwise PyQt will detect
# the default excepthook is in place and override it.
def handle_exception(exc_type, exc_value, exc_traceback):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
sys.excepthook = handle_exception
glueviz-1.0.1+dfsg.orig/glue/logo.png 0000644 0001750 0001750 00000045246 13455362716 017035 0 ustar noahfx noahfx PNG
IHDR K C4 )iCCPICC Profile c``2ptqre``+)
rwRR` ``\\ yy 5F}Yd<^\PT QJjq2]^R gd$e@좐 g ͗a_ ' v@t0l-bVep/,L(Q0200PpLOJU,.I-VK/*/J,IM !
A!ahiiI P<@X(v! ɥEePa>9 KX Lz00OE2030 ïPo\' pHYs gR IDATxy\T0
.(&hjVXiW[jMVXh^WYR"((30 KBL&|||pqquhB! I(,,dfdINNz 4H%!V#ɒ"INN"%%BCB!JdIDAAǎ رcWgq!8IUF'$p1FB!*%ɒӧOw2! !J%|vIjjCB!f7RO> /K=9w yBQKMtqG/q98xݻ֡!f75PÄJ >̾Q 4m: :WWPB!D.YP >
;H =ؿ? 48ڿ5>>>4h@B]$jǎ(9;;H $ABaw$Yʞ={# :ts.88BQ}, c (Jő=t*G&BԌ$KEa MoBΝqt4oBam,;s*ɉ^{ӲeK+D%BX$KF._*tv8swѬY3+D%BX5r`~
+ё>J$VdITۅ H:T~zѼysB!T ɒ#P ;Һuk+E$BXYfstqӓNQXA899 U:BO, 9{y;A|| -!d9MjNq."/\@_zW777ƻ/[Ŀu+[xO$!@vYΜ>DΜdΝ=KJNϟ/㠦4mڐ-ӬUKkZUso,ǰ TJĪvn\VL /gJ*GKX1cѳ> ?,e40[ܮ]nxVDo߹ #(j4ƛ p?gW>d/KYeúN;HJ%j:hH o-1 ɒ0G+F#Ԓ=boUO<#:m2
EÔ <-(vtlׄ?>tk._@^^ ˖.v9<䓖
prv7VHaϚt e0|"mΖoϽ 5;̣+|"'2on i&ItFV
d)Tr˛VZ.u3 fD}%oij:wFeY!l,{? fmmz+^mIT3w3| دBD%;!!ݭ8S2aJpgTp_\dx0 qM5}Z}m#f:M~de%Y*ŭA>egeՋd nswwNJ1%}m
J7gD-c)ٳ|Z)Qݽ96ÃZtf-w#cJZ(]ÝF&3H3kptCԈNLXc iYfq֔lbPXXx"'G'6퍫k}Zg.e0&JWw3Y[G"
S7*|T0
H`H0I$momcHMI}}}}Թ3=z& Z gZGb1Sf0(]=>)O$YfѺ,L1 5z/5Ws* FZZ[laAt܉G$bذ:lE՝`Fi3{=MD z kAXaŒuks}|y})t+Fݻ3g(,,LJqwwǍ?28{$ J`fwynx kyw Q;^)O!mo}mmh7BT̗,,b,0Z8aqrr*s4TO$rssYt)_YåK%9;;Ӳe
'ά ̚77s, $)YV stM\ip1tCe+{ sqq-oM kpj' ? ʽf4oJ5jD;zs-]iߚ&Md"++SNq`v+!~> Zޡ[z-eOeQ¡odYLƍ>.2%m۶,edd0n*Zsppŗ_bq8;WmP(ڵ/VfVK>ug`s{Q Q%f1/Oǹ K^i쉋e*ۤq/P00[:x[˥3kT֢wud -3ڿIQf-?@hh(9sEF0uҶbXpXҬn/sYcbK#[ʰ<5*CYٍY,0hf/foȾ/Y% 1*,,dM5*KQK]:ԩnږϛ7sȑ#պ'qFǶlْ?X/L
/^,s,ˋ̮êRy[< g#r oN[G!;chI(f[ \gZOB2+t(Sgab)>j&oF% srr"|_#~A9z49mqwX...oOO@7oTd隻X{Y =Z>y5:~VO<#f` Ӌ g¬y Z:h.{sg^L|Gmeu<}U?`\8Ԣ $K=C>NתdiX2;Z ?~}^zb ;VvRG qZU+HN$&^x6{본,jRw/adHM'o8 y !Dg;V ڄٚT l0HƩ'z?LP?˥81F5F+_-Vŋ9>6g+niii,^"uY፟XR7X Q*NCסOH *Da8̲)jY{'Jip-P-Q%Qmw mL~~{H]M6M4H >>̏*2+Wqtg T.RЈdlx&c>N!]Js~۲QACWVz~n6IDg4)`0q5еk \cҷ__ pL&˖.h}5e8m WV;%ށٖ])]Qwʕ1X,IDuҙ?XRĢ˗-cȠysF 3={ҧo J< R|~ܸuVO"б{%WI][`J?~Ru$k٪LXӘf Э8IEѧ>gNgc}:Uz= :v0k:f͚;oWys=@KdK2%Dg0sd͇WggXv_Q!lj#=2D+ǘfX*Y&[Ջ/ɓ&x$%%1>AFmhڴZ+EEErEN>͡CػgU%] ,]Fs YzRf\Fˬ%yF$gWxhP)*7UXD6Zwc\BjoU%aQڱnzymVZU-7EQH8@¡gLО/9yG9j.,ZN;>z(]tQ58C:d:M!MdLZ) SQU[ vW3" Fl)&tc$Yƿf ❷Xl___ϘA+kdggJDs 3Z|}L '8YJaVuE,:k|ËS+ '#ˈ6lV@GAJWőb$A5v$Yҥ |)Yr?o̥ cP=8=P䞞xzڠgUͽݖaHʐn v_{u+"Lj . VQ{Z*hӣ/RV2Lp6oI7gǟk. 8ȉD233KܪsppI&jՊvt
O>jچgP>'Dz 0-5hzrr0^ml*]7 Qǩ{G =u?p9'ŀKdIX+w}7w}
ɡ˝ vmwu+.~^%d@$lI!٪f_?XYg,Tu֥ɢ%Y6dh5UJIY _54iI-lUmX/n]H:5 +, Q)gRְQC+FRZ.q[Rͥk՞0[!vKo
]k>$KBTSaa!'N(w{FʟO"z1aAFc7<|S
ːdIjJHH@חI&V&d6o!D)ҨiIvU];@$ %Y~rҦm[+FS uk0[B
I+e}!498Z-BaO!L%!aڵnjHጺ͵md QIn!ɒfc++ܧV|β$$KB>#7TQFzmV,NfG lLQOH$N:ŲK+gCld
T F+ $KBT(̙=; 5Jْωki&SԝYVA%!he
ٳ'۷RDOFnMĵ0I~ ]zMn8_m^!߷hat8
T, =K,ybH9,h QUY1k :Gn5,E%!*o {
g/i\6zɡ6"3ARwK*5;MT܆ '˕;WQUij
%Ssϊo
Q{l Btm;8GI;L%!ۯ2z(.^XcN;[!kдįfw|fG$ǘ[!иWv!Η(E%!J)**b3q?M/[!2G *Q5?.Bu6!d"%9FuWBC`
?{a$Y'N0&r4UG ř7~WWiuo%ߓr UOl ,Tl:4YBG+ՒxbJQ:G%! .(rK ]tQ1жouN6۰-n6ה|6*ttѱj <&OP7a}9ƅYe[SUZif6rÑhլ$CF& !VnUБXJ,:Y ϦČWg9zEU筌XջD0v. jog2`%4PU [BHWܐg/Նu 3< Uz19Vm7$b
h+A5?7I͉^MHL:&(kar?ڿGU mzGr6̈́~ cb-pl -"VC2FsU0>㲚T.}DX06D
>՛)w2lVG$Qbga5u=*6Uk(a?/P1Q"{wH$KBLJw-I&t!Ld-72lQ6=6!d Wr-:Xxae-:1V5)ݠ
`Ӧ1{oMTۖDDZF, n~X}pfZ `CLdQ9/xcAAē{G 888:$hyj
'z(9u}ߺ9ލ$F%.egs*016I=iq S*-3ѣ/n)_u[ $IJZU_Q<LzMScE=g˧1c)'j5DM$&j"^_:y IDATyH} ^'\/31?"Y1ղSPX,YrquSJ˫fidM/cbg(bf!}D1`mw4>UjMX xg)V ]R|r&\4o\~p.4f*$e!Tn QQVu_(Oؘo b-[YN[0ŋw _x[!j)O<;AoرQء$D$KBG OzSUƙם[?!ɶyN&~< 7"TZR%!)P~ٽaXH<Sg vzwNvef [GQu >[YaZ` TooIk;jPPu;۔Ƌ6 SZ/
Wo$
m2hk8|J:ܹ d?x}D-o Agld02:}4]FJ 5.;K_'7}ۼe59jélY?_̷:kL4Iup[ ,QJvTƑCY:oX_ptn% Hb[Zyfʉ_5S!^NbF_+H|D(md\]`o+ Vvm8!Dx2a2c ;6hx9c[v'aܷ !^ Exj -+2vƢ6;6;P6"ԿWQ0T,t eƜ$6.aS>`odU/1$KBh<
geSd 緍kY` X )X92CwV:]؏ 7`I᷵K f舩 q2W[S_ v4RS'||sm-3"c~l} WF ^WQ(BG_ > 0撛'GxMЍn:t: K|9ZYFu2¥'Ώ~'oe'og _N:7E2$| wՋ5 >Ey0FG~o8d +?_ WYYpSG=m&rH$0
Z'Z'֛v^-죥.zOhp^ Cv&)gIM:4e\ zpsr p74YS Zϧ=U#97ht^ NHἲC28pq{XKً;z&`:߫tW0rT K}*kzzE`PW[" ЕYd 77?Ʌl(+..xxxw4jڔ&MikuQcB2^ K: \g-:O-:O/ΌB/0?ѢG6.{, !j̽U , QI$LT,?v - Ǖkv Pp5d
`# y W^
E }AW[QX yӟ%wQ
ݽp ? ģ_ҕ]SK'߸|^х?FoÉ<Ty{'fd"'RVn ?=.ixj^M8?w
pD8_葻BqAF)Mwg|ͥ8t\1"4۟ʺ.=*:Intp} >O=F U~j-KL<ٵk/^k*G
bښWB;~MLy;1H| 6wt.Lɞs\jL\f}\n
gM/U擝1[.^?pϓ|= W\r2 cf CzP$ H_r%ƌrvG:Γ$BڒS42_sfp9q:B֔ MRVg6d0l!|/ ~]L92 |*yLN<4~Sxt7^&[z_^B}g|s4=wFgľh 3p\
~orpoI_` .={x.s>/%}7çpq;x sל 3w]9Me cv6GSyu J~9ĕ
:pH0p2U6Gv)&)j;qұ]
U> n1?JخZ xPҿ ^+瑣Y[\߲T8rGʙù M5D R|c'ld7DJ ۓ(JrrP=bܯ RG0D9(JNeo@JArμW RdY=J|@7 %z`W 諤%=z$jр %;Jz%ʹO*qC,E^ )䟔Rd\ RC *QI}.H xR̸QW/g[r/&)q]}ǔsŞ= *q},5)J5ynb*vh}+rVyL%%Wb4&+z)q|yԟAw*(i*qC(^bw~xWb}yRRןū/Jϫׯ7ncrlЕכ
ϵ9ֲsY !,LD-]56
1sٷ$fִ#;ܐӭ"Vy\Q.0uq+DJK\ H7tHQ&}ݒŜwʽ ^ `Ө#05|Z_;J[)r Ñ|b6}z$rX6p xnVtk;%o}Xi9g.
~27[3iVlg玏z|sp3>ۂ\
Mc<ߚKbϽƧ #'UZt/TXF˕[7sckiM᭡cs/Zwl<թ9A0П -m<,p$ɳb 5Jʅp+rVpc0N=:v8W1Ek3 4oTj\K} ]IT@>PD3rɾ`
as0m݇FIyjI%c}S}`i
N0Esh{]#} C )jܬjf? ۃhοTfdҾ99$\1 ͢o9k4Hq]Jυ%v Cf3 䔯q 6]
)v]Y/ʯ@ [ {M;H fǀfr .ji@j>Es=g81z^vd'y[ɋVs(x'mp$|8z CLg/r@Mgt_);%]H6uv/rE<#w-8}%rfK [n{ >#|9hZvƑDN+9s}']4 IKVa4ibIGS܀ K7]w#7ute^U"ٹ
2cqU4 -G _~ ]SyFLnm#9V2~8{=#|G\8Y _Z w+qTt+JgÅаWۛ/VUΫׯ VR/̯qe稪ɒy(z 3egn 'N:ZJC|B\75vjo)e} vk 8.?}v69Wrh̕_ſ8 p.|7 c w{gfraG }Vv{(^}}_ Ƒ/$o8p\h4-ns+Rù#0d"W8w:6+vZ1\L86jW:wkd 9ޟN[EG*&Uή@" yii O W1 ,R嘮q <WqDRvyD\
$=&n x3\YPpZxZ^: G I>Z:8 }f ǯwNJOe ϱ HҐ 8!iOp3dܲ:p.wW Ǟ@^]
'}S
9g?_W~w%`;nejM S էup(nSҸp>M 433 |vz.EF#n 7 wWWvb5 5)#ɺE>bI#b];
ߨyWW5 JۘɸA-bѓrx\}g
qf-8>m.GWϽh W-'m 1s91S~|EoerDX _*N ?Hzc&?chϼéifb.WS ]Λqx µF9Qo0Fq/h7
` џx5 +:\ZZDoi2hjKkjrIx&[\}s V\8tl^ Nŕ]'N` " hث'
{U<Ńί/M#S_̷ :tF1xڷoF赏Ώ~KZUҦf<_!XBQ%d/s_SN! |(ct>ci-%4ľcN$&^lK5g|j1=ӵpf/N&n[,~N &Ng0{hY?܄vI-1#cFYe.Y2$aJQ_,(2 sf.(ڿMϞ=l*q&ZO
KcYa.IH8Oܞ?bKpX{A^ӵK3B5S(?Tv K%양"6'OR+ԺA?(`2}69Mr8$Rr8wgHk IDAT\dIЖCVhJ5ќӛ5 x/Œ%θy ;2h`5CBQȤhi0
pts ,|} 0Q ޠR4
gB!j:Ѳ$#~?31egԨ xdeeV+ ! !,ܹs`u(͚U(]MJ$\Ҳx'1 v74zH!,h[ټi#B!$YRQneUJ-`:!6"ɒe0 ̝3 ݻsOvZ&F֡ !2$D^ye6?<<F&ڤeIR'$H/IKKrDB!lI%!JIHHpVD!=dIR7pgۅB-,#))x=ϛe}xyyM6t
j刄Bؒ$KW}6 < Se됄hZ DXblB[p8rFcd<4aDBw͛HMI??p?:֡ !2&KVѡJ^|iҴ)-Zr YǎG-8]EoQy6i1cl Bi֩FgEaqVSB! %K.\VU2:Of@]HOKgŊO8t {r00|Bag,uGGGUeqݦ pQF ŋ?y&c 3/F&X-Yj,\0l
* '-]>|ۘ~\՛9E3g59bB#Y8p c7036 V~nD=rESح[%YBq̳$ X !_$YNf ,w{h^VF!dIK/4Bu vBa$YvdqU>}Xf5}'m۶eɼ{88TmT!,w"Jjj*Q_b1MtN'[r)2I{w _|)+~L G+n+,}
B!iYv#;;>M0QEQ :x^AK1eePʩYsI`BBQI$}FzzMpa\:po/s[%Y4F!$KnrmW1JAj BM%a7T1U.BTF%a7pts+sk:Y$6!$KnD vݺIe ܴ mLrh- %.fd a7 X֛>-[)((gϞ QM [[h#x{[1z!u$K 0u[vJ ! B!D$YB!@
w3Si U[uɄBQdL{%٠B!jEԠm']6.(((`O?q1y5#| l BQZ,www.]dx)4ZqVzZ:Olj-|,\]wmBJԊ @ WIKMլZ M۶hJh47cǍ5>qN^"Q|2/N}[ФiE&BTV$K |j ۹cEEE^x d k9Ύ?,sۥKؼy>B!FʪpBa>I۴[ &q {c* H+h\Cء>h ]X@P/jZ,6:8SZSp~ 7 L,peYƋ _{`ɋ `~bح,ˈ܇q`? \V ެ(bTpg'NDӉV{ \H,Tk֢ ss @X HK 5h^' n{ǣ,;is5kDl{ pIuCQӬ ˫5\ٌŇ8~Fl=ڊ~SXvr4= X1 * @X HK b A, $% @X HK b A, $܌ro 9;=~G Pk7߽#b|n{@w0у IENDB` glueviz-1.0.1+dfsg.orig/glue/icons/ 0000755 0001750 0001750 00000000000 13752535025 016462 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/icons/glue_zoom_to_rect.png 0000644 0001750 0001750 00000022755 13455362716 022727 0 ustar noahfx noahfx PNG
IHDR } } l% pHYs .# .#x?v tEXtSoftware Adobe ImageReadyqe< %zIDATx} t ř_-Ylm/c[mlc 6dYpÒM`7dO6YH
f& r:d H,lK%zK =fF3ݵ]UU= O{zG3j1xմ- oq-zA8=u vہ17̾ ڴ'#r1 ,s7xٟ4 K3+f϶" d\c ULJ`# ƔqcnJS
r!;(;{8{hnZʊGs_ULf D͡ʵd_a8 0|`j&'K8ν Ϩ5}
.56B z$ūJ,y>./؋@D-1;>vϜŤ;`[wm=;6qЯo ۰
W$H h'؈ s0. T FN
{.|EEtA89D`Dț_
}MgebʹȚ_[~䈚 Q+hlPPkv TݏA!pGMiY]֪5
&MQMF:%ntkߒ~0tԑ+܍mKG*V!nd%M[wHu%0xlmG8!jOOFSVm715
5 `z'jE܅%vGոcI$~Iw[F`%dKJxTg `=
}l y
WIwPnHLI0\ l03}\ qT&)˹ tZӧrMwﹴ - L/(#ROy5d
VVdb!#jFs|e%PNM/d ̜M{(&rF#'`opKh\8$! <:Km^ܱ< _5cɂ.bK j64n(\u'3In1 p5t?3i &N
e?ii|N}C}wў.4ՅYYYR 0PF2 R| ZnyuC )˟FHD-Pm7,}ͣ0֥O$݄m="/gҝ.K#M>9ht+? DD~\@BUUt& S &=IaC&k瘯tG EPܰIkܯ
&_)EH[{R>} BC=cbG\zj
/ƾz *,_;TJ#vm=#j_0^
W۴.-jS'ZAQSv>Й:gswuU8߿GRm}yc2 Oyߟ
s' ~ތr1A'Y}o 1q<JH'eW2d;,Х
% w# ~u,)=g,نtiCy矬_3&
2r0䵁
Ժ3J;ZZ:;P9 $WJ~2#qxM;
y-vJD5"P=vMd95
: wn:ŎwMNctI<B+?O|> [(־69fбuL7 d g>ܞ# ~R Fn>z=K}օZ8 yB↕s $ggGKlOD~dH@wNڦ] tA-U.qv_ZX]2X ̤I6|CZZ }ԩ A}")W9֖ #
/@b%w} JA+B
S7dA)aWtJwv خQKE5h^fHҎ1tTxzZ0z\ӎ~ZUwo`nJՔӁ_pu)UN B(YzO=$WM 77R7ݚewJq T"jjgMg@ | UOA60n.c8wo j_6R5Sf^^^H"j (+B@vk̇*K OؽU:v99;!ʝ<ٯƜ$|xCVt]{߯oٿ/_Vv< !5?#!p'tÞ UПo- so[u[eg߃m9ݣ@2n{ PL7sU qHj{Q鷺_{,@ g30I%Pu eaW tB҉[o_YYzf8sGo hDj\ 9l܆[ | Ps!]qv5ǷJQu/UxnwniĞ}t'̬Kjp0hܰ'/5r@ _<᜴GOkP t!sm6;d@D`P
<_#}ǧ
2B9ZCf9.7d7/ G
r;"52\5@c˿v{m,]^ Ov\c* !$EOmb1غ?| QTeOE?#lqsuN/ hMzFoGGwfK̴9
7ÃU yU& 3ylyCo3kG I?Dcg[8Ďwl2fпj.$$nPx=x4q` K]Յ>89:5GrHV ,wὯ9 L10L5 +foڻa~q LKK Yܩ3P\ rPt 3OTf㒵&9-ڴ ][/N\3VpB xqۭILwͣ!!wu@l4d #v\,v\_kY!5>4Nlc3t ^=&nL5x:` N4> T '7^:k|
-ICW_茼Ѭٞ;N
D` (8s ~mzM]kntY]k4Cv^y V gq>>?];:~%e V|f?9}ok(^
7+h 醍 %7| LWzb)s?XPƵw1{H ]Ok RpJfaSM]N55_/'g(̞ddwȡpS05# w N÷ @͐k
ns q\eWuѫ{^a˗ v!j,8I}~mݠ0tʋ4+ we2p,vPerköFϨcoccb?jCX``n -HͅG12÷\eۼ\?\
N~N yq"4|&h Țp-
ӳ_ Ug{L8k(gdMҊZf:39!@om p 7'k9cqJflFŋ7f@Ԏ78 F f2s tY7S_2.>]T"I !v&I)t? |yČip7͑6ҽn!㇑1RǟJ-FNȧv $P& ' Kڵw8/]e13_sJ9iGqoI$&6啕5v/rpßۅc4FAKρJp?R鎵'>i<gD
ϿKApz;h#o5 XA²ԡ^G0Q,jMbT>6?բsշ>Ԇ`@ۉCt~E:Za#e5
; 냌3t{QvHŪNYԺ1'~|M}n29tjeP< BѴ"])h,̩ؓte;O '30n(*-=I8
JH|-:`2$K${d;!`I2iT6m"}l^G[+ 9x kl&)$W 4/NMD1i舏1`]*yӧ#jjMW܆;*Cv P+4Νyre&@1}} ] "߁Z4s,*i!r`܈)Q q4yE՝XVXuSThI웬2w6@ S AΝ{e/G?Q&6nu J G a:{6bOu`kV6t&?\ 8z?TͣIY9J
!b?V~ƍay0-5M])kǤMνZnyEwܚ3,yg02Du11vE2*nd 唪3a97`o8 'mVlrC?6
S9"a1[ l_5L /4(LBĶ:RGEπZp5'rguI $㠻}!(6@ӂKCg9CA6h~gRKױkX.To!_X 8s$9[(GKMc}~ƾhغԽ!kqwmո:?:)99 Uk*bfliɢ|zۀ9a U͚Mn-bE$֣7|%9
to*K0W ձ6
:G@Amp\rîN@L5!1m
7B12 SF'7p)a-$0KqVi˒RD7YMdmo/1X3'!v˦
W`&&L!i5P A[ݎc7n;ޮ >Z2/˶ 8fA'
7-3KivN fdk-s˄vn9VጼIj
6| 6<0gT1-nˋJ-7<)ƞyſ.]ቯL8,)ݓު6x'Yt
|Pp^ymEucuq[zC#;. lsm.2kز2®WeZtduu%kيk c,K19ej(X۞6]95.ib#;]!qYLφ399m4R(7$ 2nL横
žҬ W5N+tJƯJ,GP\ĴD,evߞ=gmuIؔt&*5^UB̪= Zo 83$5λ-w9rpw8byN|EG
xk&
)rc~V{{J %tP7OܴؓtyϿ@%+&ɄY5 'Kjd$1H ,x K ɡXpfzGЅ ;?z ,K*|+1 `ˍ,Ys :'_ H"1: `&q$Wu}" UI%.P"rpGZ+ܴS_ UT9ԯ_Z[/N,LɈn*~[;6wsMWlA{T>:I V tu]/p? 6,8;)%4p'
e z:ʌ:HjM*FD} ;9tf.@S|Z"lE4,\ 5{48iڐt
!(:NJf ĊУѶmJGaU5e퍥3!OMH,:y [?}5'RY0h".=b T_yq_}z3M Gd!ƒ-dmw@98oUŋTr.2#u-ukܥmkʂMzŒ~MmXAvzS"#&[}}ͥ/g`ȟ@]:ģ 1w0>'\, !؈vk+ny-Awl(6myVϪ./=RT@3oDک 76f/_ycE& Zor<,/'E"Yg'), ȑ2kqʌ8)
ԖR>#/b@g>v ŐBx?\噯Q2|^, "
:tP%RV5ܒ۪^2η2R
) m㡠* -_7g<}$K;M¬yM \;|gk͇K
) +V1O虿x|B?ݟ9%i7ܤR I:'9'ꞬP ]}bb|]t iغr_G*B n$2,QEwI+" qOɇ=m+W8.X{yy6lLKؑ#-+YVȟGH72So/U_c7] Y =-lG,u˺m:X)%ի*zW^WLQVh?x熘# x
RxA ÇxjYħ ¼C'~ ڽ:|:jڜWR^ B ްh)5}bM,& A# ~ C#{wBY|y}Jg΄tKf/#s#2dd=%64B8)si<=l5/$KuN i=0|h ŶhM2eD{I7=''MO9~@g}ׅ; CH K }X%HpF%9UWQ&`L WngpAFbLet |hXHd64 #GǀO _g+Dz` ]~r%gD]C0E] .u:$4ANVr>Zv`Cd3{σ1>@
) +lbH7gl{ŮGlwua
V}<=}nӎS M!|kyp4"+*v/bVST
53f:TFdX`j?{ dFy+l'0^{lۤzurjB/^B'B
"yEFM+ԔTL
Y'jYDZ|#}Oj
q{T |b# ]@D͞9(z9y# %cɪɃ48Å@.smUDMKı\A>rTG:ѭa5lN81K ;q6S`\ү^24^{'ꘝ ž | kc ~q
1=XU݈ճq ̾G ͞ #̔Tq([ x oq-zA8=ޮUO ?* IENDB` glueviz-1.0.1+dfsg.orig/glue/icons/tests/ 0000755 0001750 0001750 00000000000 13752535025 017624 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/icons/tests/test_main.py 0000644 0001750 0001750 00000000463 13502206677 022165 0 ustar noahfx noahfx import os
from .. import icon_path
def test_icon_path():
path = icon_path('glue_replace')
assert os.path.exists(path)
path = icon_path('glue_replace', icon_format='png')
assert os.path.exists(path)
path = icon_path('glue_replace', icon_format='svg')
assert os.path.exists(path)
glueviz-1.0.1+dfsg.orig/glue/icons/tests/__init__.py 0000644 0001750 0001750 00000000000 13502206677 021724 0 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/icons/glue_link.svg 0000644 0001750 0001750 00000011642 13455362716 021165 0 ustar noahfx noahfx
glueviz-1.0.1+dfsg.orig/glue/icons/qt/ 0000755 0001750 0001750 00000000000 13752535025 017106 5 ustar noahfx noahfx glueviz-1.0.1+dfsg.orig/glue/icons/qt/__init__.py 0000644 0001750 0001750 00000000037 13502206677 021220 0 ustar noahfx noahfx from .helpers import * # noqa
glueviz-1.0.1+dfsg.orig/glue/icons/qt/helpers.py 0000644 0001750 0001750 00000004200 13605357235 021120 0 ustar noahfx noahfx from qtpy import QtGui
from matplotlib.colors import Colormap
from glue.utils.qt import mpl_to_qt_color, tint_pixmap, cmap2pixmap
from glue.icons import icon_path
__all__ = ['symbol_icon', 'layer_icon', 'layer_artist_icon', 'get_icon', 'POINT_ICONS']
POINT_ICONS = {'o': 'glue_circle_point',
's': 'glue_box_point',
'^': 'glue_triangle_up',
'*': 'glue_star',
'+': 'glue_cross'}
def symbol_icon(symbol, color=None):
bm = QtGui.QBitmap(icon_path(POINT_ICONS.get(symbol, 'glue_circle')))
if color is not None:
return QtGui.QIcon(tint_pixmap(bm, color))
return QtGui.QIcon(bm)
def layer_icon(layer):
"""Create a QtGui.QIcon for a Data or Subset instance
:type layer: :class:`~glue.core.data.Data`,
:class:`~glue.core.subset.Subset`,
or object with a .style attribute
:rtype: QtGui.QIcon
"""
icon = POINT_ICONS.get(layer.style.marker, 'circle_point')
bm = QtGui.QBitmap(icon_path(icon))
color = mpl_to_qt_color(layer.style.color)
pm = tint_pixmap(bm, color)
return QtGui.QIcon(pm)
def layer_artist_icon(artist):
"""Create a QtGui.QIcon for a LayerArtist instance"""
# TODO: need a test for this
from glue.viewers.scatter.layer_artist import ScatterLayerArtist
color = artist.get_layer_color()
if isinstance(color, Colormap):
pm = cmap2pixmap(color)
else:
if isinstance(artist, ScatterLayerArtist):
bm = QtGui.QBitmap(icon_path(POINT_ICONS.get(artist.layer.style.marker,
'glue_circle_point')))
else:
bm = QtGui.QBitmap(icon_path('glue_box_point'))
color = mpl_to_qt_color(color)
pm = tint_pixmap(bm, color)
return QtGui.QIcon(pm)
def get_icon(icon_name):
"""
Build a QtGui.QIcon from an image name
Parameters
----------
icon_name : str
Name of image file. Assumed to be a png file in glue/qt/icons
Do not include the extension
Returns
-------
A QtGui.QIcon object
"""
return QtGui.QIcon(icon_path(icon_name))
glueviz-1.0.1+dfsg.orig/glue/icons/glue_move_x.svg 0000644 0001750 0001750 00000015306 13752534424 021523 0 ustar noahfx noahfx
glueviz-1.0.1+dfsg.orig/glue/icons/glue_home.png 0000644 0001750 0001750 00000016614 13455362716 021151 0 ustar noahfx noahfx PNG
IHDR } } l% pHYs .# .#x?v tEXtSoftware Adobe ImageReadyqe< IDATx ]u}o%3, L&IJBB`A*GT@-(VZQsGiOmUвBЀ1$d0{N&{df2ow;-b @mtmr *+[zyo6=?çhOF1fXm
< 6dT( Uav?ǧϼ:3'I:VW
C3(/8F٦7&}=/ gےwM[C$8率8E@MSԒ7v,NdY 8ꭀskpCT?/CnC=tdz R@ #ꢏ~郱Aoa'KIN#ۮH=}X0SI|Ytaǂ*`G/
爢a) $ 7Ūu楙 [W2_V_\G KР R
5pP<PSMNLWF :̭[X:x
i2D r8U?ڣ%[51Nف'e 8d p.@3SH:dyKO8ntaBR|Ύ<3{ q3\\>:0F̪9l Zy#H#}v4) <9GNUcPG#=ʱ3Η LLAf=m)໌ރ5 FgN-9#unsʞ#@c`tE4<"t*S5;jbc =sF$7!(ɾ-ɞ$
y.sߍEIz͘xSI?R5]LݯrsƵS;sb:!μl+\9 ARHlOr*7);ϹGx(Rqʾ5Κ#ݓA ?
oK|Qɻ3*UKT
} q^jBonS;5QzH= .s8x7P YL3*pKIkgo˲ aθ 5' طxlw|WAćR_L)`L
G۶,5ge:߮| ;#L@ abjNo +
;mI7p_x倱 cQa><U OY|[/蠋3)=m/ spt@ /U[ ;Px2ci %x@ϥqcclۦNK9 g[xti([ *\2)z
e Tv >0[~8^;IW3=HbJ {*uX|{Κ/vLO6ڠ65օΓ_[B 9`ˢ>v:zgm<ׇ}4^_ʹ>l<3\ b1kwQ}C#v y&dgg0$Qe~y_%_ܒ
.u'xR \TJA"v9P3v r]Ed; ='Bv rXO q;?tڕ &f)̑RzR _ SÖ]Up مz35z 8\fwȐ
YȷE]*\O&x;~'2.w-H&E;yNj[xe| dX{
uM)
t=c=4zrˑ_qg"$
:|9 &Q08&9%
xsYK?:H[3Yݶ.V uGY44Vt#c,?ҵ*pڥ wi:zy `I'ҡaݮ2jcHgW\]
scu:rXE ӕ6{5haﺋN\r5hKTyD]+uyzLrO(? K OpؒuCGХko OF ?
ԑe３6N\
ÊtKedNeU, ky t
gE3%)\`n}q7?.^ddۃi8#'vl5|
Sf";w wC.ےuѫ`skA@T)U-eN eD/¥k|}E \4S ;R?-<*c c^j,%ˣ-۲9>eUS8*!ik& pV ϸ8#]^{!~O!.-Ƨ3~/8xLXy?(EK:3RopFN6=y,.2d8oj|vH}{!gmW^Ҍ~AZ1C\p Xu-1kֲuZ9c0O) pkp`xluĒoE |oр' eԹoط5}Jj]? 1DZҍ>̺cp`p`#ܭSJX O
< ,z8;fe9:AYװ]1 Nʺ~g{~} G #}T;qHdίZ ykڱH
ܬ O t~3ft w,,n2݊ _-ak*ٞDB m۟}:݃_R'LO؉2̧ظ;ǎܑb8c;]2
=2^e
Pόݳ)|^ot|MÀ?UwC$ ~$4 >G1S/*Y#ZEC࠹u+D u>S#nX._ &Y+@&൵7phZŢk'*[Uǭ~Ϧ
{!}gGskG3Zr\1XrLhF2 cŦ~wl=wt ?mͫ[sW}n) ʀߑ7Og'K`'$\SIb8h C %>YѲ=QAWy]'п<, Ͼ9xoڦM?cU(&)"k]c_XRuMUu< _6^e]p'f -J!/+8==NQs;TJ)3o\zO߸μ
|Ҥ[ hx `'D]#3GO}{s ݠ$ Re-/~U_1VM_'v?|ax __8), 0x m|{$p
"}ugϧj=i m -lnYQ͢t
=ǰm4w ƱV ❣(ﷀ| R͓jO}_MPU]Y@nM3a#" pqeXT/ é];3}&R_
\o2bD3}D7&#yJiCc HHa Tk7?Ku2ϝ: Սa\ ,wqQ4~b <)bۖu7ϞKW- k;MIeS8G{ 6c /⟓`ᢒ,GOO}k/;p[akkƌ3) Ln|+9[Z1,X9}M7ДkJ}^ϝ7ȖVP74 P/(?q\4V]Shnin.{qC/_wX5O!y u_Ǻо/$joo#܇|}Aܵj
>7^nmjjJ&Oپ#@ỏ`bVz RZaA5C>+p Kxb[q /8
<*[_:(Ffg&O =~eu/eTȨVu
3#>>ps=[~ל\~M
>@ҎFx&*b5xOxo@>:U==h0;nmo ,p<vLRa*-Xdl)A 䱺ʔC> m. Ky6<\KʍK?o8SDR![Y[ #HnyԆݩC?_[QU!T=QY*l^ ?o~+;0AXIzl,[Ȳt@&Zҍ"boX1jJbXr 5,$ `۾rD-}\y
N`Y;DX.~/$ uHO7$q_);25w+Yi<*`? WGFzrr0A778)~}^F~UώL P ^5mF8(ۀ]
k J0~@ \.? 1E -u]έXz(Czr-HU9<#|F#%8t
< iq bzQe pO}GTu@Ֆz!T9`'%xʑHI]Ƶ@Eއ z5G,2cPmY[9͎ ? /#܈
! V|RXO#nr*
Ffx(/<@(eŴG2-G%aCh{v!>zQĀFZge5bT
?_>R8喯2
}wDVBvK:#g#M
r
'T !j nPzD a 0Y˯wo d>
5Yd~HA]{(݇ oo7ZoAc'pj@em_k3 Oo}jh Z
f"<Ƌsxyr'
81)S4=#L +)މ*@7/? oXnv4oãO䱲^FW
V^Ft W IENDB` glueviz-1.0.1+dfsg.orig/glue/icons/glue_slice.png 0000644 0001750 0001750 00000002752 13630201003 021266 0 ustar noahfx noahfx PNG
IHDR } } l% pHYs .# .#x?v tEXtSoftware Adobe ImageReadyqe< wIDATxMnF@'NlP@@9@ b/
}Kh 캓 jvmV-
;~d8Ґ X}3 HtrE.'||۞ Oۉot]_~aQs !{! G:cN /tֱ#?w_?ߏ?? .' 6,]##;kr[ zK' mmΕu:«))NV&#N8[6{(NΩ.#ߤ#:ftyt ϶UzGx5-\ w9c+| nHΗW
9$܅t&|W)+BR:vh:ݶ3mc%By9 5v_.-
5uS`waX4 i|ІmppWpD8R8 ha q WvI>kj翿wMd wz_L ڙhG:z"pڈܢ^'G |1:_e)⸥,Cqҥw#(J>Q7GS7os]N8Yd 3\Nٕ'|lTWÂ|"-֢^kVDqPoo)ZTA]sѤ|ٖIEPa ktf xʧ=e"ZwGʗ[-4kwTK $O%P\F\˂DxӘ;%} ^KHKL@"egvi!F&#-L~SJO "Xw^Pw승xeқonz_~;/=FPlqTR{Ʊ"8FPFԦr+bjqW @\U ^PGyj lZ42`څ{0CG1] Ho\!l tWo8 Z6l3r [[i|< a_\yЭ
O 0W% IENDB` glueviz-1.0.1+dfsg.orig/glue/icons/glue_lasso.svg 0000644 0001750 0001750 00000014321 13455362716 021346 0 ustar noahfx noahfx
glueviz-1.0.1+dfsg.orig/glue/icons/glue_filesave.png 0000644 0001750 0001750 00000015060 13455362716 022011 0 ustar noahfx noahfx PNG
IHDR } } l% pHYs .# .#x?v tEXtSoftware Adobe ImageReadyqe< IDATx]]$u>gfwv~G%k!D/JQ ˄ď2ؐ_ Fz
Q`NH H؊$ۑ}OsU_{HDh ,`-@_苶 }/Eiz}Ojtz؞Ӿ|k/=vӋnrF|z|hcT N
@-SJ_:=6AxJ 6)/VsGm+uG/x(;5L `JUOMp9|wF!xf:GR- 8)?88Ҁg,u68Vwwvv.LznwYz O4=Gi A h4>ӏVWV pR7\.R8,/| r/7/88=v MÝ~^h
FA, &i" YA(E y@*aV 5 8MmbC"{aTP
7 X y29dqlZ `f;1 3oRƁbtl@C>N8'栜PTv8p>+|?2?TJE'护/,@YH. l0B l(?ebLk,Ahrsa|7s \A bc43:Hclg;Ɯ pr&|B}
ۻKU$Cc:&w"#I J;v "S/@ά $˫KȘbB}ukəBi:G+?XT9%K+nn-{5̎{[\x|'Ǥ U%ҵxD`x uvVA .'DP@>st
Fc'gذ&_;Ka}bKhMG,^ٹ ]vl'(\f|<y8 \u|D!kԩ
g FO[v;
m8n6JO'COD˛ i Fڰw #t:Qpr0DV"F䉛\TuPumnQ"{D3
z E @2{ٽ9%rEF
ՀSYQ$2FyDpP:{ܿyvH4]&i(,8
pg C4Lڡ|ԣ0&}^( kgHmjIFiUl<Hk`{cYcinz2ɡ宬?v;:3 m?cIb
"3'3eLz}Ww31Cn B6 Lkl蔑Jb8Aq1C|,}Ȥo;"N !N
mE\ a ,nG]u "ww# /wp9N[7NRjrfҤ@k5'N> $Qo g:gC(|G]0'/m 4 5e?
YLS 8",eLhC<. 3+&aad k-i
t˱@^`( 睢VL j:2 S#qOnU8
U' t[0D31*ϦQ^$-HO3 ˲'buam~C4~I9Tԡ\.bLXȎo~dD6@"+RJ1 B,l H2X Er2Ey*b[t8i#A%l@eљMOX
"(=7A;.M1+FO+z&&n^T:>5>Ne3~u-$$! VKVSbBdr ,"bg#Y܌fylğk2yon@N}fاs: +S^EG6 (5p൙%$C>HF "7 59fk@ w,ю U t1 ál
c_fU1t">:G9aRχ !a'EPҍMWkvcߙ or,45KG禴 q|R lUWҢ'l0kfsYƊqɡgI
1Ea0}oݤx
E_Qmǧћ!5vd 1P){éYĥ;3l4ΰ͝N47?ӦI@sQ]Ln x` ^ DWG"f̓)% ;RԄM 튌LȆ:^cWz s*,Y(TQdd!7MtKxQFM\Q\!yx U"1( D?_ -:WG˽q
F]II2Хn LNf*__O㶠x
# EѥK RY3 : W
p^C| KVlˍ 3i j1Y O7+hǍ(P$l"YZEg#)Z` . Ir* >*gڑ )5g|\[
<ubJ zV ` 4J [-P|- 1Sd?" oUJ ӡvg%tf/2O 7 G7r2>]@%|K, A4gu`i9/ =hD.D7`C bhg$RA.z ŋuxጃnL8<" 4U9FLF
VPgٴ|qEYoY$!0$hnoeeЏόYo{'t VmguwϤx
)$Nȷ]hr) ߏόYo鉮4M<=vBb';>BЗ˽Xj/"xR<:\I>P.9;Rj njy?GS$/ 1F
gУ֟XjD#HFN].8z8;ןh WHX0PV%CdQ\xL7NP)"P?ӯN4 ^zly`LPfU|Sb"r
&Bz2c1 ZAq"lʿ?;\MR(BN$-'k/wV.w{vs)g "Y ^T \ٽRV W4S}OOp\!Q-Ňv\zv֝%C 7 %CpfpPbD4|F'5]
rIō01Օ(v_L>K"F|Ff 0 I 3DKE'*l-w0
tt![
D)
ˎi>Ҧ _. Kٍ
)l&OP0Ր6bh}[JE}KDk[p-֤5b2| n)ߨ )yAhPSG4UVr nٹJsL ulw#b\/W|q̌ 7/mFb;ṊO '|6Į}%cf/ZDl usd/xpǁ/L8&b9[OdBa &elp
I^KqeBP|&_` \+f'^% ?Бc,XhٯܮLĪfS{B5j~ /Mɤ^
GٲM F\.kc~[:_7X;Cm?Ɉ& J$ciJ.gZ=womhf8]y_^z1Y3Nlw BV[YX[SbD wBoq!L]]*FUIFNU@VA( f= Z <#kͻ YPfR2.kbE,eW&%5|ܻs~]Qc-eL=uȖp TU xإ#79g$2ĂL]^ϑ3L|0j#bx` OcFIiS=&_МG k&Pb^bUE8*\kO[um {:!
va\&/DK4& x)$j9Yg[_LSn GN<9 :"|3bbur7a;?3u n=ӥZc4,I &~,nHBM K:#npͥǭ8+fMVʅAE(2{\eL ^l?Cvvj htPdRT zHI3u%SIQI诧 ` h 4 gOka$S6L
'a)GfnnlN_^d~^6n>Tph.rp_,.!=46)Ϥ//ŀt;S{)6$oHîm`V>=GϞ8?5f?怃܌ DbSK+ 'R ? K_7N $~֝[`>