def test_auto_update(self):
m = markers.text(y=1, x=2, text='a')
nose.tools.assert_true(m.auto_update is False)
m = markers.text(y=[1, 2], x=2, text='a')
nose.tools.assert_true(m.auto_update is True)
m.add_data(y1=1)
nose.tools.assert_true(m.auto_update is False)
m.add_data(y1=[1, 2])
nose.tools.assert_true(m.auto_update is True)
def test_auto_update(self):
m = markers.text(y=1, x=2, text='a')
assert m.auto_update is False
m = markers.text(y=[1, 2], x=2, text='a')
assert m.auto_update is True
m.add_data(y1=1)
assert m.auto_update is False
m.add_data(y1=[1, 2])
assert m.auto_update is True
def test_auto_update(self):
m = markers.text(y=1, x=2, text='a')
assert m.auto_update is False
m = markers.text(y=[1, 2], x=2, text='a')
assert m.auto_update is True
m.add_data(y1=1)
assert m.auto_update is False
m.add_data(y1=[1, 2])
assert m.auto_update is True
def test_auto_update(self):
m = markers.text(y=1, x=2, text='a')
nose.tools.assert_true(m.auto_update is False)
m = markers.text(y=[1, 2], x=2, text='a')
nose.tools.assert_true(m.auto_update is True)
m.add_data(y1=1)
nose.tools.assert_true(m.auto_update is False)
m.add_data(y1=[1, 2])
nose.tools.assert_true(m.auto_update is True)
def _test_plot_text_markers():
s = Signal1D(np.arange(100).reshape([10, 10]))
s.plot(navigator='spectrum')
for i in range(s.axes_manager.shape[0]):
m = markers.text(y=s.sum(-1).data[i] + 5, x=i, text='abcdefghij'[i])
s.add_marker(m, plot_on_signal=False)
x = s.axes_manager.shape[-1] / 2 # middle of signal plot
m = markers.text(x=x, y=s.inav[x].data + 2, text=[i for i in 'abcdefghij'])
s.add_marker(m)
return s
def test_plot_markers_mpl_options():
# check if required parameters are shown in repr
_test_plot_markers_repr(markers.arrow(10, 20, 30, 40),
['x1', 'y1', 'x2', 'y2',
'edgecolor', 'arrowstyle'])
_test_plot_markers_repr(markers.ellipse(10, 20, 30, 40, color='red'),
['x', 'y', 'width', 'height',
'edgecolor'])
_test_plot_markers_repr(markers.horizontal_line(10),
['y', 'color'])
_test_plot_markers_repr(markers.horizontal_line_segment(10, 20, 30),
['x1', 'x2', 'y', 'color'])
_test_plot_markers_repr(markers.line_segment(10, 20, 30,40),
['x1', 'x2', 'y1', 'y2', 'color'])
_test_plot_markers_repr(markers.point(10, 20),
['x', 'x', 'color', 'size'])
m = markers.rectangle(10, 20, 30, 40, color='red')
_test_plot_markers_repr(m, ['edgecolor'])
# check if 'color' property is converted to 'edgecolor'
assert 'color' not in m.marker_properties
assert 'edgecolor' in m.marker_properties
assert m.marker_properties['edgecolor'] == 'red'
_test_plot_markers_repr(markers.text(10,20,"test"),
['x', 'y', 'text', 'color'])
_test_plot_markers_repr(markers.vertical_line(10),
['x', 'color'])
m = markers.vertical_line_segment(10, 20, 30)
_test_plot_markers_repr(m,['x', 'y1', 'y2', 'color'])
def test_add_several_permanent_markers(self):
s = Signal1D(np.arange(10))
m_point = markers.point(x=5, y=5)
m_line = markers.line_segment(x1=5, x2=10, y1=5, y2=10)
m_vline = markers.vertical_line(x=5)
m_vline_segment = markers.vertical_line_segment(x=4, y1=3, y2=6)
m_hline = markers.horizontal_line(y=5)
m_hline_segment = markers.horizontal_line_segment(x1=1, x2=9, y=5)
m_rect = markers.rectangle(x1=1, x2=3, y1=5, y2=10)
m_text = markers.text(x=1, y=5, text="test")
m_arrow = markers.arrow(x1=4, y1=5, x2=6, y2=6, arrowstyle='<->')
m_ellipse = markers.ellipse(x=10, y=11, width=4, height=6)
s.add_marker(m_point, permanent=True)
s.add_marker(m_line, permanent=True)
s.add_marker(m_vline, permanent=True)
s.add_marker(m_vline_segment, permanent=True)
s.add_marker(m_hline, permanent=True)
s.add_marker(m_hline_segment, permanent=True)
s.add_marker(m_rect, permanent=True)
s.add_marker(m_text, permanent=True)
s.add_marker(m_arrow, permanent=True)
s.add_marker(m_ellipse, permanent=True)
assert len(list(s.metadata.Markers)) == 10
with pytest.raises(ValueError):
s.add_marker(m_rect, permanent=True)
def test_save_load_permanent_marker_all_types(self):
x1, y1, x2, y2 = 5, 2, 1, 8
s = Signal2D(np.arange(100).reshape(10, 10))
m0_list = [
markers.point(x=x1, y=y1),
markers.horizontal_line(y=y1),
markers.horizontal_line_segment(x1=x1, x2=x2, y=y1),
markers.line_segment(x1=x1, x2=x2, y1=y1, y2=y2),
markers.rectangle(x1=x1, x2=x2, y1=y1, y2=y2),
markers.text(x=x1, y=y1, text="test"),
markers.vertical_line(x=x1),
markers.vertical_line_segment(x=x1, y1=y1, y2=y2),
]
for m in m0_list:
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testallmarkersfile.hdf5'
s.save(filename)
s1 = load(filename)
markers_dict = s1.metadata.Markers
m0_dict_list = []
m1_dict_list = []
for m in m0_list:
m0_dict_list.append(san_dict(m._to_dictionary()))
m1_dict_list.append(
san_dict(markers_dict.get_item(m.name)._to_dictionary()))
assert len(list(s1.metadata.Markers)) == 8
for m0_dict, m1_dict in zip(m0_dict_list, m1_dict_list):
assert m0_dict == m1_dict
def test_get_one_string(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)), y=list(range(3)), text='one')
m.axes_manager = s.axes_manager
assert m.get_data_position('text') == 'one'
s.axes_manager[0].index = 2
assert m.get_data_position('text') == 'one'
def test_save_load_permanent_marker_all_types(self):
x1, y1, x2, y2 = 5, 2, 1, 8
s = Signal2D(np.arange(100).reshape(10, 10))
m0_list = [
markers.point(x=x1, y=y1),
markers.horizontal_line(y=y1),
markers.horizontal_line_segment(x1=x1, x2=x2, y=y1),
markers.line_segment(x1=x1, x2=x2, y1=y1, y2=y2),
markers.rectangle(x1=x1, x2=x2, y1=y1, y2=y2),
markers.text(x=x1, y=y1, text="test"),
markers.vertical_line(x=x1),
markers.vertical_line_segment(x=x1, y1=y1, y2=y2),
]
for m in m0_list:
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testallmarkersfile.hdf5'
s.save(filename)
s1 = load(filename)
markers_dict = s1.metadata.Markers
m0_dict_list = []
m1_dict_list = []
for m in m0_list:
m0_dict_list.append(san_dict(m._to_dictionary()))
m1_dict_list.append(
san_dict(markers_dict.get_item(m.name)._to_dictionary()))
assert len(list(s1.metadata.Markers)) == 8
for m0_dict, m1_dict in zip(m0_dict_list, m1_dict_list):
assert m0_dict == m1_dict
def test_get_one_string(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)), y=list(range(3)), text='one')
m.axes_manager = s.axes_manager
nose.tools.assert_equal(m.get_data_position('text'), 'one')
s.axes_manager[0].index = 2
nose.tools.assert_equal(m.get_data_position('text'), 'one')
def _add_xray_lines_markers(self, xray_lines):
"""
Add marker on a spec.plot() with the name of the selected X-ray
lines
Parameters
----------
xray_lines: list of string
A valid list of X-ray lines
"""
line_energy = []
intensity = []
for xray_line in xray_lines:
element, line = utils_eds._get_element_and_line(xray_line)
line_energy.append(self._get_line_energy(xray_line))
relative_factor = elements_db[element][
'Atomic_properties']['Xray_lines'][line]['weight']
a_eng = self._get_line_energy(element + '_' + line[0] + 'a')
intensity.append(self.isig[a_eng].data * relative_factor)
for i in range(len(line_energy)):
line = markers.vertical_line_segment(
x=line_energy[i], y1=None, y2=intensity[i] * 0.8)
self.add_marker(line)
text = markers.text(
x=line_energy[i], y=intensity[i] * 1.1, text=xray_lines[i],
rotation=90)
self.add_marker(text)
def test_save_load_permanent_marker_all_types(self, tmp_path, file):
filename = tmp_path / file
s = self.s
x1, y1, x2, y2 = 5, 2, 1, 8
m0_list = [
markers.point(x=x1, y=y1),
markers.horizontal_line(y=y1),
markers.horizontal_line_segment(x1=x1, x2=x2, y=y1),
markers.line_segment(x1=x1, x2=x2, y1=y1, y2=y2),
markers.rectangle(x1=x1, x2=x2, y1=y1, y2=y2),
markers.text(x=x1, y=y1, text="test"),
markers.vertical_line(x=x1),
markers.vertical_line_segment(x=x1, y1=y1, y2=y2),
]
for m in m0_list:
s.add_marker(m, permanent=True)
s.save(filename)
s1 = load(filename)
markers_dict = s1.metadata.Markers
m0_dict_list = []
m1_dict_list = []
for m in m0_list:
m0_dict_list.append(san_dict(m._to_dictionary()))
m1_dict_list.append(
san_dict(markers_dict.get_item(m.name)._to_dictionary()))
assert len(list(s1.metadata.Markers)) == 8
for m0_dict, m1_dict in zip(m0_dict_list, m1_dict_list):
assert m0_dict == m1_dict
def add_xray_lines_markers(self, xray_lines):
"""
Add marker on a spec.plot() with the name of the selected X-ray
lines
Parameters
----------
xray_lines: list of string
A valid list of X-ray lines
"""
line_energy = []
intensity = []
for xray_line in xray_lines:
element, line = utils_eds._get_element_and_line(xray_line)
line_energy.append(self._get_line_energy(xray_line))
relative_factor = elements_db[element][
'Atomic_properties']['Xray_lines'][line]['weight']
a_eng = self._get_line_energy(element + '_' + line[0] + 'a')
intensity.append(self.isig[a_eng].data * relative_factor)
for i in range(len(line_energy)):
line = markers.vertical_line_segment(
x=line_energy[i], y1=None, y2=intensity[i] * 0.8)
self.add_marker(line)
text = markers.text(
x=line_energy[i], y=intensity[i] * 1.1, text=xray_lines[i],
rotation=90)
self.add_marker(text)
self._xray_markers[xray_lines[i]] = [line, text]
line.events.closed.connect(self._xray_marker_closed)
text.events.closed.connect(self._xray_marker_closed)
def get_text_list(texts: Union[list, np.ndarray],
coordinates: Union[np.ndarray, list], **kwargs) -> list:
"""Return a list of text markers.
Parameters
----------
texts
A list of texts.
coordinates
On the form [[x0, y0], [x1, y1], ...].
kwargs
Keyword arguments allowed by :func:`matplotlib.pyplot.axvline.`
Returns
-------
marker_list : list
List of :class:`hyperspy.drawing._markers.text.Text`.
"""
coordinates = np.asarray(coordinates)
if coordinates.ndim == 1:
coordinates = coordinates[np.newaxis, ...]
marker_list = []
is_finite = np.isfinite(coordinates)[..., 0]
coordinates[~is_finite] = -1
for i in range(coordinates.shape[-2]): # Iterate over zone axes
if not np.allclose(coordinates[..., i, :], -1): # All NaNs
x = coordinates[..., i, 0]
y = coordinates[..., i, 1]
x[~is_finite[..., i]] = np.nan
y[~is_finite[..., i]] = np.nan
text_marker = text(x=x, y=y, text=texts[i], **kwargs)
marker_list.append(text_marker)
return marker_list
def test_markers_properties(self):
m = markers.text(x=1, y=2, text='a')
m.set_marker_properties(fontsize=30, color='red')
nose.tools.assert_true(m.marker_properties == {
'color': 'red',
'fontsize': 30
})
def test_get_one_string(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)),
y=list(range(3)),
text='one')
m.axes_manager = s.axes_manager
nose.tools.assert_equal(m.get_data_position('text'), 'one')
s.axes_manager[0].index = 2
nose.tools.assert_equal(m.get_data_position('text'), 'one')
def test_iterate_strings(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)),
y=list(range(3)),
text=['one', 'two', 'three'])
m.axes_manager = s.axes_manager
assert m.get_data_position('text') == 'one'
s.axes_manager[0].index = 2
assert m.get_data_position('text') == 'three'
def test_iterate_strings(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)),
y=list(range(3)),
text=['one', 'two', 'three'])
m.axes_manager = s.axes_manager
assert m.get_data_position('text') == 'one'
s.axes_manager[0].index = 2
assert m.get_data_position('text') == 'three'
def test_get_one_string(self):
s = Signal2D(np.zeros([3, 2, 2]))
m = markers.text(x=list(range(3)),
y=list(range(3)),
text='one')
m.axes_manager = s.axes_manager
assert m.get_data_position('text') == 'one'
s.axes_manager[0].index = 2
assert m.get_data_position('text') == 'one'
def test_dict2marker(self):
m_point0 = markers.point(x=5, y=5)
m_point1 = markers.point(x=(5, 10), y=(1, 5))
m_line = markers.line_segment(x1=5, x2=10, y1=5, y2=10)
m_vline = markers.vertical_line(x=5)
m_vline_segment = markers.vertical_line_segment(x=4, y1=3, y2=6)
m_hline = markers.horizontal_line(y=5)
m_hline_segment = markers.horizontal_line_segment(x1=1, x2=9, y=5)
m_rect = markers.rectangle(x1=1, x2=3, y1=5, y2=10)
m_text = markers.text(x=1, y=5, text="test")
m_point0_new = dict2marker(m_point0._to_dictionary(), m_point0.name)
m_point1_new = dict2marker(m_point1._to_dictionary(), m_point1.name)
m_line_new = dict2marker(m_line._to_dictionary(), m_line.name)
m_vline_new = dict2marker(m_vline._to_dictionary(), m_vline.name)
m_vline_segment_new = dict2marker(
m_vline_segment._to_dictionary(), m_vline_segment.name)
m_hline_new = dict2marker(m_hline._to_dictionary(), m_hline.name)
m_hline_segment_new = dict2marker(
m_hline_segment._to_dictionary(), m_hline_segment.name)
m_rect_new = dict2marker(m_rect._to_dictionary(), m_rect.name)
m_text_new = dict2marker(m_text._to_dictionary(), m_text.name)
m_point0_dict = sanitize_dict(m_point0._to_dictionary())
m_point1_dict = sanitize_dict(m_point1._to_dictionary())
m_line_dict = sanitize_dict(m_line._to_dictionary())
m_vline_dict = sanitize_dict(m_vline._to_dictionary())
m_vline_segment_dict = sanitize_dict(m_vline_segment._to_dictionary())
m_hline_dict = sanitize_dict(m_hline._to_dictionary())
m_hline_segment_dict = sanitize_dict(m_hline_segment._to_dictionary())
m_rect_dict = sanitize_dict(m_rect._to_dictionary())
m_text_dict = sanitize_dict(m_text._to_dictionary())
m_point0_new_dict = sanitize_dict(m_point0_new._to_dictionary())
m_point1_new_dict = sanitize_dict(m_point1_new._to_dictionary())
m_line_new_dict = sanitize_dict(m_line_new._to_dictionary())
m_vline_new_dict = sanitize_dict(m_vline_new._to_dictionary())
m_vline_segment_new_dict = sanitize_dict(
m_vline_segment_new._to_dictionary())
m_hline_new_dict = sanitize_dict(m_hline_new._to_dictionary())
m_hline_segment_new_dict = sanitize_dict(
m_hline_segment_new._to_dictionary())
m_rect_new_dict = sanitize_dict(m_rect_new._to_dictionary())
m_text_new_dict = sanitize_dict(m_text_new._to_dictionary())
assert m_point0_dict == m_point0_new_dict
assert m_point1_dict == m_point1_new_dict
assert m_line_dict == m_line_new_dict
assert m_vline_dict == m_vline_new_dict
assert m_vline_segment_dict == m_vline_segment_new_dict
assert m_hline_dict == m_hline_new_dict
assert m_hline_segment_dict == m_hline_segment_new_dict
assert m_rect_dict == m_rect_new_dict
assert m_text_dict == m_text_new_dict
def get_text_list(
texts: Union[list, np.ndarray],
coordinates: Union[np.ndarray, list],
**kwargs,
) -> list:
"""Return a list of text markers.
Parameters
----------
texts
A list of texts.
coordinates
On the form [[x0, y0], [x1, y1], ...].
kwargs
Keyword arguments allowed by :func:`matplotlib.pyplot.axvline.`
Returns
-------
marker_list : list
List of :class:`hyperspy.drawing._markers.text.Text`.
"""
coordinates = np.asarray(coordinates)
if coordinates.ndim == 1:
coordinates = coordinates[np.newaxis, ...]
marker_list = []
is_finite = np.isfinite(coordinates)[..., 0]
coordinates[~is_finite] = -1
for i in range(coordinates.shape[-2]): # Iterate over zone axes
if not np.allclose(coordinates[..., i, :], -1): # All NaNs
x = coordinates[..., i, 0]
y = coordinates[..., i, 1]
x[~is_finite[..., i]] = np.nan
y[~is_finite[..., i]] = np.nan
text_marker = text(
x=x,
y=y,
text=texts[i],
**kwargs,
)
# TODO: Pass "visible" parameter to text() when HyperSpy allows
# it (merges this PR
# https://github.com/hyperspy/hyperspy/pull/2558 and publishes
# a minor release with that update)
# text_marker = text(
# x=coordinates[..., i, 0],
# y=coordinates[..., i, 1],
# text=texts[i],
# visible=is_finite[..., i],
# **kwargs
# )
marker_list.append(text_marker)
return marker_list
def test_markers_auto_update():
# test data for fixed marker
pos = [1, 2, 3, 4]
# test data for auto_update marker
pos_list = np.array([[1, 3, 5], [2, 4, 6]])
pos_2d = [pos_list + pos[i] for i in range(4)]
s = Signal2D(np.arange(2 * 3 * 4 * 5).reshape(2, 3, 4, 5))
marker_list = []
for _auto_update, _pos in [(False, pos), (True, pos_2d)]:
_markers = [
markers.vertical_line(_pos[0]),
markers.horizontal_line(_pos[0]),
markers.vertical_line_segment(*(_pos[0:3])),
markers.horizontal_line_segment(*(_pos[0:3])),
markers.rectangle(*_pos),
markers.ellipse(*_pos),
markers.arrow(*_pos),
markers.line_segment(*_pos),
markers.point(_pos[0], _pos[1]),
markers.text(_pos[0], _pos[1], "test"),
]
for marker in _markers:
assert marker.auto_update is _auto_update
marker_list += _markers
assert len(marker_list) == 20
s.add_marker(marker_list)
for iy, temp_marker_list in enumerate(pos_list):
for ix, value in enumerate(temp_marker_list):
s.axes_manager.indices = (ix, iy)
for marker in marker_list:
_xy = [marker.get_data_position(ax) for ax in ('x1','y1','x2','y2')]
if marker.auto_update is False:
_xy2 = pos
else:
_xy2 = [pos_2d[i][iy, ix] for i in range(4)]
_name = marker.name
if marker.auto_update is False:
if _name == 'vertical_line':
assert _xy2[0] == _xy[0]
elif _name == 'horizontal_line':
assert _xy2[0] == _xy[1]
elif _name == 'vertical_line_segment':
assert _xy2[0:3] == [_xy[i] for i in (0,1,3)]
elif _name == 'horizontal_line_segment':
assert _xy2[0:3] == [_xy[i] for i in (0,2,1)]
elif _name in ('rectangle', 'ellipse', 'arrow', 'line_segment'):
assert _xy2 == _xy
elif _name in ('point', 'text'):
assert _xy2[0:2] == _xy[0:2]
else:
raise ValueError('Unknown marker : ' + _name)
def test_save_load_text_marker(self, tmp_path, file):
filename = tmp_path / file
s = self.s
x, y = 3, 9.5
color = 'brown'
name = "text_test"
text = "a text"
m = markers.text(x=x, y=y, text=text, color=color)
m.name = name
s.add_marker(m, permanent=True)
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_text_marker(self, mpl_cleanup):
x, y = 3, 9.5
color = 'brown'
name = "text_test"
text = "a text"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.text(x=x, y=y, text=text, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_text_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_plot_markers_zorder(reversed_order):
s = Signal2D(np.full((10,10),20))
s.axes_manager[0].name='x'
s.axes_manager[0].scale=10
s.axes_manager[1].scale=10
s.plot()
marker_list = [
markers.rectangle(35, 45, 65, 75, edgecolor="yellow", facecolor="cyan", zorder=3),
markers.text(10, 20, "Text", color="white", size=30, zorder=4),
markers.ellipse(40, 60, 30, 25, edgecolor='white', facecolor='red', linewidth=4, zorder=8),
markers.arrow(10, 10, 50, 50, arrowstyle='<|-|>', edgecolor='white', facecolor='red', linewidth=1, shrinkA=2, shrinkB=2, zorder=8.5),
markers.arrow(10, 15, 50, 60, arrowstyle='<->', edgecolor='red', facecolor='red', linewidth=3, shrinkA=2, shrinkB=2, zorder=2.8),
markers.rectangle(10, 20, 60, 70, edgecolor="red", facecolor="green", fill=True, zorder=2.7),
markers.text(50, 60, "Text", color="white", backgroundcolor="blue", size=40, zorder=6.6),
markers.ellipse(70, 40, 30, 25, edgecolor='blue', facecolor='red', fill=True, linewidth=4, zorder=7.5),
markers.line_segment(50, 10, 40, 80, color='cyan', linewidth=3, zorder=3.2),
]
if reversed_order:
marker_list.reverse()
s.add_marker(marker_list)
return s._plot.signal_plot.figure
def test_save_load_text_marker(self):
x, y = 3, 9.5
color = 'brown'
name = "text_test"
text = "a text"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.text(
x=x, y=y, text=text, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_text_marker.hdf5'
s.save(filename)
s1 = load(filename)
m1 = s1.metadata.Markers.get_item(name)
assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def _estimate_textbox_dimension(self, dummy_text='My_g8'):
# get the dimension of a typical textbox in the current figure
dummy_style = copy.deepcopy(self.edge_label_style)
dummy_style['bbox']['alpha'] = 0
dummy_style['alpha'] = 0
tx = markers.text(x=(self.axis.low_value + self.axis.high_value) / 2,
y=(self.smin + self.smax) / 2,
text=self._text_parser(dummy_text),
**dummy_style)
self.signal.add_marker(tx)
dummybb = self._get_bbox_from_text_artist(tx.marker)
tx.close()
text_width = dummybb.width
text_height = dummybb.height
return text_width, text_height
def get_markers(self, labels):
'''Get the markers (vertical line segment and text box) for labelling
the edges
Parameters
----------
labels : dictionary
A dictionary with the labels as keys and their energies as values.
E.g. for EELS edges it could be {'Mn_L2': 651.0, 'Cr_L3': 575.0}.
Returns
-------
vls : list
A list contains HyperSpy's vertical line segment marker
txs : list
A list contains HyperSpy's text marker
'''
xytext = self._get_textbox_pos(labels)
vls = []
txs = []
for xyt in xytext:
vl = markers.vertical_line_segment(x=xyt[0],
y1=xyt[1],
y2=xyt[2],
color=xyt[4])
tx = markers.text(x=xyt[0],
y=xyt[1],
text=self._text_parser(xyt[3]),
color=xyt[4],
**self.edge_label_style)
vl.events.closed.connect(self.signal._edge_marker_closed)
tx.events.closed.connect(self.signal._edge_marker_closed)
vl.auto_update = True
tx.auto_update = True
vls.append(vl)
txs.append(tx)
return vls, txs
def test_iterate_markers():
from skimage.feature import peak_local_max
import scipy.misc
ims = BaseSignal(scipy.misc.face()).as_signal2D([1, 2])
index = np.array([peak_local_max(im.data, min_distance=100,
num_peaks=4) for im in ims])
# Add multiple markers
for i in range(4):
xs = index[:, i, 1]
ys = index[:, i, 0]
m = markers.point(x=xs, y=ys, color='red')
ims.add_marker(m, plot_marker=True, permanent=True)
m = markers.text(x=10 + xs, y=10 + ys, text=str(i), color='k')
ims.add_marker(m, plot_marker=True, permanent=True)
xs = index[:, :, 1]
ys = index[:, :, 0]
x1 = np.min(xs, 1)
y1 = np.min(ys, 1)
x2 = np.max(xs, 1)
y2 = np.max(ys, 1)
m = markers.rectangle(x1, y1, x2, y2, color='green')
ims.add_marker(m, plot_marker=True, permanent=True)
m = markers.arrow(x1, y1, x2, y2, arrowstyle='<->',edgecolor='red')
ims.add_marker(m, plot_marker=True, permanent=True)
m = markers.ellipse((x1+x2)/2, (y1+y2)/2, x2-x1, y2-y1,
edgecolor='yellow')
ims.add_marker(m, plot_marker=True, permanent=True)
for im in ims:
m_original = ims.metadata.Markers
m_iterated = im.metadata.Markers
for key in m_original.keys():
mo = m_original[key]
mi = m_iterated[key]
assert mo.__class__.__name__ == mi.__class__.__name__
assert mo.name == mi.name
assert mo.get_data_position('x1') == mi.get_data_position('x1')
assert mo.get_data_position('y1') == mi.get_data_position('y1')
assert mo.get_data_position('text') == mi.get_data_position('text')
for propkey in mo.marker_properties:
assert mo.marker_properties[propkey] == \
mi.marker_properties[propkey]
def test_add_several_permanent_markers(self, mpl_cleanup):
s = Signal1D(np.arange(10))
m_point = markers.point(x=5, y=5)
m_line = markers.line_segment(x1=5, x2=10, y1=5, y2=10)
m_vline = markers.vertical_line(x=5)
m_vline_segment = markers.vertical_line_segment(x=4, y1=3, y2=6)
m_hline = markers.horizontal_line(y=5)
m_hline_segment = markers.horizontal_line_segment(x1=1, x2=9, y=5)
m_rect = markers.rectangle(x1=1, x2=3, y1=5, y2=10)
m_text = markers.text(x=1, y=5, text="test")
s.add_marker(m_point, permanent=True)
s.add_marker(m_line, permanent=True)
s.add_marker(m_vline, permanent=True)
s.add_marker(m_vline_segment, permanent=True)
s.add_marker(m_hline, permanent=True)
s.add_marker(m_hline_segment, permanent=True)
s.add_marker(m_rect, permanent=True)
s.add_marker(m_text, permanent=True)
assert len(list(s.metadata.Markers)) == 8
with pytest.raises(ValueError):
s.add_marker(m_rect, permanent=True)
def test_add_several_permanent_markers(self):
s = Signal1D(np.arange(10))
m_point = markers.point(x=5, y=5)
m_line = markers.line_segment(x1=5, x2=10, y1=5, y2=10)
m_vline = markers.vertical_line(x=5)
m_vline_segment = markers.vertical_line_segment(x=4, y1=3, y2=6)
m_hline = markers.horizontal_line(y=5)
m_hline_segment = markers.horizontal_line_segment(x1=1, x2=9, y=5)
m_rect = markers.rectangle(x1=1, x2=3, y1=5, y2=10)
m_text = markers.text(x=1, y=5, text="test")
s.add_marker(m_point, permanent=True)
s.add_marker(m_line, permanent=True)
s.add_marker(m_vline, permanent=True)
s.add_marker(m_vline_segment, permanent=True)
s.add_marker(m_hline, permanent=True)
s.add_marker(m_hline_segment, permanent=True)
s.add_marker(m_rect, permanent=True)
s.add_marker(m_text, permanent=True)
assert len(list(s.metadata.Markers)) == 8
with pytest.raises(ValueError):
s.add_marker(m_rect, permanent=True)
def regression(self, roi, signal=None, axes=None):
if signal is None:
f = self.reg_tool.widget.ax.figure
window = f.canvas.parent()
sw = window.property('hyperspyUI.SignalWrapper')
if sw is None:
return
signal = sw.signal
sig_axes = signal.axes_manager._axes
if axes is None:
axes = self.reg_tool.axes
else:
axes = sig_axes[axes]
i_ax = sig_axes.index(axes[0])
slices = list(roi._make_slices(sig_axes, axes))
for i, a in enumerate(sig_axes):
if i != i_ax:
slices[i] = a.index
y = signal.data[slices]
x = axes[0].axis[slices[i_ax]]
# TODO: If in signal dim, iterate through navigation space
reg = stats.linregress(x, y)
x1, x2 = np.min(x), np.max(x)
y1, y2 = np.array([x1, x2]) * reg[0] + reg[1]
m_l = line_segment(x1, y1, x2, y2)
signal.add_marker(m_l)
m_t = text((x2+x1)*0.5, (y2+y1)*0.5,
"y = %.4gx + %.4g, R=%.4g" % reg[0:3])
signal.add_marker(m_t)
self.record_code("signal = ui.get_selected_signal()")
self.record_code("axes = " +
str(tuple([sig_axes.index(a) for a in axes])))
self.record_code("roi = utils.roi." + str(roi))
self.record_code("<p>.regression(roi, signal, axes)")
self.reg_tool.cancel() # Turn off functionality as we are finished
def get_text_list(texts: list, coordinates: np.ndarray, **kwargs) -> list:
"""Return a list of text markers.
Parameters
----------
texts :
A list of texts.
coordinates :
On the form [[x0, y0], [x1, y1], ...].
kwargs :
Keyword arguments allowed by :class:`matplotlib.pyplot.axvline.`
Returns
-------
marker_list :
List of :class:`hyperspy.utils.markers.text`.
"""
coordinates = np.atleast_2d(coordinates)
return [
text(x=x, y=y, text=t, **kwargs)
for t, (x, y) in zip(texts, coordinates)
]
def regression(self, roi, signal=None, axes=None):
if signal is None:
f = self.reg_tool.widget.ax.figure
window = f.canvas.parent()
sw = window.property('hyperspyUI.SignalWrapper')
if sw is None:
return
signal = sw.signal
sig_axes = signal.axes_manager._axes
if axes is None:
axes = self.reg_tool.axes
else:
axes = sig_axes[axes]
i_ax = sig_axes.index(axes[0])
slices = list(roi._make_slices(sig_axes, axes))
for i, a in enumerate(sig_axes):
if i != i_ax:
slices[i] = a.index
y = signal.data[slices]
x = axes[0].axis[slices[i_ax]]
# TODO: If in signal dim, iterate through navigation space
reg = stats.linregress(x, y)
x1, x2 = np.min(x), np.max(x)
y1, y2 = np.array([x1, x2]) * reg[0] + reg[1]
m_l = line_segment(x1, y1, x2, y2)
signal.add_marker(m_l)
m_t = text((x2 + x1) * 0.5, (y2 + y1) * 0.5,
"y = %.4gx + %.4g, R=%.4g" % reg[0:3])
signal.add_marker(m_t)
self.record_code("signal = ui.get_selected_signal()")
self.record_code("axes = " +
str(tuple([sig_axes.index(a) for a in axes])))
self.record_code("roi = utils.roi." + str(roi))
self.record_code("<p>.regression(roi, signal, axes)")
self.reg_tool.cancel() # Turn off functionality as we are finished
def test_iterate_markers():
from skimage.feature import peak_local_max
import scipy.misc
ims = BaseSignal(scipy.misc.face()).as_signal2D([1, 2])
index = np.array([peak_local_max(im.data, min_distance=100,
num_peaks=4) for im in ims])
# Add multiple markers
for i in range(4):
xs = index[:, i, 1]
ys = index[:, i, 0]
m = markers.point(x=xs, y=ys, color='red')
ims.add_marker(m, plot_marker=True, permanent=True)
m = markers.text(x=10 + xs, y=10 + ys, text=str(i), color='k')
ims.add_marker(m, plot_marker=True, permanent=True)
xs = index[:, :, 1]
ys = index[:, :, 0]
m = markers.rectangle(np.min(xs, 1),
np.min(ys, 1),
np.max(xs, 1),
np.max(ys, 1),
color='green')
ims.add_marker(m, plot_marker=True, permanent=True)
for im in ims:
m_original = ims.metadata.Markers
m_iterated = im.metadata.Markers
for key in m_original.keys():
mo = m_original[key]
mi = m_iterated[key]
assert mo.__class__.__name__ == mi.__class__.__name__
assert mo.name == mi.name
assert mo.get_data_position('x1') == mi.get_data_position('x1')
assert mo.get_data_position('y1') == mi.get_data_position('y1')
assert mo.get_data_position('text') == mi.get_data_position('text')
assert mo.marker_properties['color'] == \
mi.marker_properties['color']
def test_markers_properties(self):
m = markers.text(x=1, y=2, text='a')
m.set_marker_properties(fontsize=30, color='red')
nose.tools.assert_dict_equal(m.marker_properties,
{'color': 'red', 'fontsize': 30})
def test_markers_properties(self):
m = markers.text(x=1, y=2, text='a')
m.set_marker_properties(fontsize=30, color='red')
assert (m.marker_properties ==
{'color': 'red', 'fontsize': 30})
