def test_get_data_shape_point(self):
m0 = markers.point(5, 5)
m1 = markers.point((5, 10), (5, 10))
m2 = markers.point(((12, 2, 9), (1, 2, 3)), ((2, 5, 1), (3, 9, 2)))
m3 = markers.vertical_line(((12, 2), (2, 5), (9, 2)))
m4 = markers.point(5, 5)
m4.data['x1'][()] = np.array(None, dtype=object)
m4.data['y1'][()] = np.array(None, dtype=object)
m5 = markers.vertical_line(9)
m6 = markers.rectangle(1, 5, 6, 8)
m7 = markers.rectangle((1, 2), (5, 6), (6, 7), (8, 9))
m8 = markers.point(
np.arange(256).reshape(2, 2, 2, 2, 2, 2, 2, 2),
np.arange(256).reshape(2, 2, 2, 2, 2, 2, 2, 2))
m9 = markers.arrow(2, 3, 4, 5)
m10 = markers.arrow((2, 3), (4, 5), (6, 7), (8, 9))
m11 = markers.ellipse(4, 5, 2, 3)
m12 = markers.ellipse((2, 3), (4, 5), (6, 7), (8, 9))
assert m0._get_data_shape() == ()
assert m1._get_data_shape() == (2,)
assert m2._get_data_shape() == (2, 3)
assert m3._get_data_shape() == (3, 2)
with pytest.raises(ValueError):
assert m4._get_data_shape() == ()
assert m5._get_data_shape() == ()
assert m6._get_data_shape() == ()
assert m7._get_data_shape() == (2,)
assert m8._get_data_shape() == (2, 2, 2, 2, 2, 2, 2, 2)
assert m9._get_data_shape() == ()
assert m10._get_data_shape() == (2,)
assert m11._get_data_shape() == ()
assert m12._get_data_shape() == (2,)
def test_add_marker_signal2d_navigation_dim(self):
s = Signal2D(np.zeros((3, 50, 50)))
m0 = markers.point(5, 5)
m1 = markers.point((5, 10), (10, 15))
m2 = markers.point(np.zeros((3, )), np.zeros((3, )))
s.add_marker(m0)
with pytest.raises(ValueError):
s.add_marker(m1)
s.add_marker(m2)
def test_add_markers_as_list_add_different_twice(self):
s = Signal1D(np.arange(10))
marker_list0 = []
for i in range(10):
marker_list0.append(markers.point(1, 2))
s.add_marker(marker_list0, permanent=True)
assert len(s.metadata.Markers) == 10
marker_list1 = []
for i in range(10):
marker_list1.append(markers.point(4, 8))
s.add_marker(marker_list1, permanent=True)
assert len(s.metadata.Markers) == 20
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 test_permanent_marker_names(self):
s = Signal1D(np.arange(10))
m0 = markers.point(x=5, y=5)
m1 = markers.point(x=5, y=5)
m0.name = 'test'
m1.name = 'test'
s.add_marker(m0, permanent=True)
s.add_marker(m1, permanent=True)
assert s.metadata.Markers.test == m0
assert m0.name == 'test'
assert s.metadata.Markers.test1 == m1
assert m1.name == 'test1'
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 _get_marker_list(ellipse_parameters,
x_list=None,
y_list=None,
name=None,
r_scale=0.05):
xC, yC, semi_len0, semi_len1, rot, ecce = _get_ellipse_parameters(
ellipse_parameters)
xx, yy = _get_ellipse_from_parameters(xC,
yC,
semi_len0,
semi_len1,
rot,
r_scale=r_scale)
marker_list = []
if x_list is not None:
for x, y in zip(x_list, y_list):
point_marker = point(x, y, color="red")
if name is not None:
point_marker.name = name + "_" + point_marker.name
marker_list.append(point_marker)
for i in range(len(xx)):
if i == (len(xx) - 1):
line = line_segment(xx[i], yy[i], xx[0], yy[0], color="green")
else:
line = line_segment(xx[i],
yy[i],
xx[i + 1],
yy[i + 1],
color="green")
if name is not None:
line.name = name + "_" + line.name
marker_list.append(line)
return marker_list
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_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_add_permanent_marker_twice_different_signal(self):
s0 = Signal1D(np.arange(10))
s1 = Signal1D(np.arange(10))
m = markers.point(x=5, y=5)
s0.add_marker(m, permanent=True)
with pytest.raises(ValueError):
s1.add_marker(m, permanent=True)
def test_add_markers_as_list(self):
s = Signal1D(np.arange(10))
marker_list = []
for i in range(10):
marker_list.append(markers.point(1, 2))
s.add_marker(marker_list, permanent=True)
assert len(s.metadata.Markers) == 10
def get_point_list(points: Union[list, np.ndarray], **kwargs) -> list:
"""Return a list of point markers.
Parameters
----------
points
On the form [[x0, y0], [x1, y1], ...].
kwargs
Keyword arguments allowed by :func:`matplotlib.pyplot.scatter`.
Returns
-------
marker_list : list
List of :class:`hyperspy.drawing._markers.point.Point`.
"""
points = np.asarray(points)
if points.ndim == 1:
points = points[np.newaxis, ...]
marker_list = []
for i in range(points.shape[-2]): # Iterate over zone axes
if not np.allclose(points[..., i, :], np.nan, equal_nan=True):
marker_list.append(
point(x=points[..., i, 0], y=points[..., i, 1], **kwargs))
return marker_list
def test_save_permanent_marker(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
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_permanent_marker(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
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 test_add_markers_as_list_add_same_twice(self):
s = Signal1D(np.arange(10))
marker_list = []
for i in range(10):
marker_list.append(markers.point(1, 2))
s.add_marker(marker_list, permanent=True)
with pytest.raises(ValueError):
s.add_marker(marker_list, permanent=True)
def test_remove_permanent_marker_name(self):
s = Signal1D(np.arange(10))
m = markers.point(x=5, y=5)
m.name = 'test'
s.add_marker(m, permanent=True)
assert list(s.metadata.Markers)[0][1] == m
del s.metadata.Markers.test
assert len(list(s.metadata.Markers)) == 0
def test_save_load_empty_metadata_markers(self, tmp_path, file):
filename = tmp_path / file
s = self.s
m = markers.point(x=5, y=5)
m.name = "test"
s.add_marker(m, permanent=True)
del s.metadata.Markers.test
s.save(filename)
s1 = load(filename)
assert len(s1.metadata.Markers) == 0
def test_save_load_empty_metadata_markers(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
m.name = "test"
s.add_marker(m, permanent=True)
del s.metadata.Markers.test
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
s1 = load(filename)
assert len(s1.metadata.Markers) == 0
def _test_plot_point_markers():
width = 100
data = np.arange(width * width).reshape((width, width))
s = Signal2D(data)
x, y = 10 * np.arange(4), 15 * np.arange(4)
color = ['yellow', 'green', 'red', 'blue']
for xi, yi, c in zip(x, y, color):
m = markers.point(x=xi, y=yi, color=c)
s.add_marker(m)
return s
def test_save_load_empty_metadata_markers(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
m.name = "test"
s.add_marker(m, permanent=True)
del s.metadata.Markers.test
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testsavefile.hdf5'
s.save(filename)
s1 = load(filename)
assert len(s1.metadata.Markers) == 0
def test_deepcopy_permanent_marker(self):
x, y, color, name = 2, 9, 'blue', 'test_point'
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color)
m.name = name
s.add_marker(m, permanent=True)
s1 = s.deepcopy()
m1 = s1.metadata.Markers.get_item(name)
assert m.get_data_position('x1') == m1.get_data_position('x1')
assert m.get_data_position('y1') == m1.get_data_position('y1')
assert m.name == m1.name
assert m.marker_properties['color'] == m1.marker_properties['color']
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_point_marker(self, tmp_path, file):
filename = tmp_path / file
s = self.s
x, y = 9, 8
color = 'purple'
name = "point test"
m = markers.point(x=x, y=y, 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_set_get_data(self):
m = markers.point(x=0, y=1.3)
nose.tools.assert_true(m.data['x1'] == 0)
nose.tools.assert_true(m.data['y1'] == 1.3)
m.add_data(y1=0.3)
nose.tools.assert_true(m.data['x1'] == 0)
nose.tools.assert_true(m.data['y1'] == 0.3)
m.set_data(y1=1.3)
nose.tools.assert_true(m.data['x1'][()][()] is None)
nose.tools.assert_true(m.data['y1'] == 1.3)
nose.tools.assert_true(m.data['x1'].dtype == np.dtype('O'))
m.add_data(y1=[1, 2])
nose.tools.assert_true(m.data['y1'][()].shape == (2, ))
def test_set_get_data(self):
m = markers.point(x=0, y=1.3)
nose.tools.assert_equal(m.data['x1'], 0)
nose.tools.assert_equal(m.data['y1'], 1.3)
m.add_data(y1=0.3)
nose.tools.assert_equal(m.data['x1'], 0)
nose.tools.assert_equal(m.data['y1'], 0.3)
m.set_data(y1=1.3)
nose.tools.assert_is_none(m.data['x1'][()][()])
nose.tools.assert_equal(m.data['y1'], 1.3)
nose.tools.assert_equal(m.data['x1'].dtype, np.dtype('O'))
m.add_data(y1=[1, 2])
nose.tools.assert_equal(m.data['y1'][()].shape, (2, ))
def test_set_get_data(self):
m = markers.point(x=0, y=1.3)
nose.tools.assert_equal(m.data['x1'], 0)
nose.tools.assert_equal(m.data['y1'], 1.3)
m.add_data(y1=0.3)
nose.tools.assert_equal(m.data['x1'], 0)
nose.tools.assert_equal(m.data['y1'], 0.3)
m.set_data(y1=1.3)
nose.tools.assert_is_none(m.data['x1'][()][()])
nose.tools.assert_equal(m.data['y1'], 1.3)
nose.tools.assert_equal(m.data['x1'].dtype, np.dtype('O'))
m.add_data(y1=[1, 2])
nose.tools.assert_equal(m.data['y1'][()].shape, (2,))
def test_set_get_data(self):
m = markers.point(x=0, y=1.3)
assert m.data['x1'] == 0
assert m.data['y1'] == 1.3
m.add_data(y1=0.3)
assert m.data['x1'] == 0
assert m.data['y1'] == 0.3
m.set_data(y1=1.3)
assert m.data['x1'][()][()] is None
assert m.data['y1'] == 1.3
assert m.data['x1'].dtype == np.dtype('O')
m.add_data(y1=[1, 2])
assert m.data['y1'][()].shape == (2,)
def test_set_get_data(self):
m = markers.point(x=0, y=1.3)
nose.tools.assert_true(m.data['x1'] == 0)
nose.tools.assert_true(m.data['y1'] == 1.3)
m.add_data(y1=0.3)
nose.tools.assert_true(m.data['x1'] == 0)
nose.tools.assert_true(m.data['y1'] == 0.3)
m.set_data(y1=1.3)
nose.tools.assert_true(m.data['x1'][()][()] is None)
nose.tools.assert_true(m.data['y1'] == 1.3)
nose.tools.assert_true(m.data['x1'].dtype == np.dtype('O'))
m.add_data(y1=[1, 2])
nose.tools.assert_true(m.data['y1'][()].shape == (2,))
def test_set_get_data(self):
m = markers.point(x=0, y=1.3)
assert m.data['x1'] == 0
assert m.data['y1'] == 1.3
m.add_data(y1=0.3)
assert m.data['x1'] == 0
assert m.data['y1'] == 0.3
m.set_data(y1=1.3)
assert m.data['x1'][()][()] is None
assert m.data['y1'] == 1.3
assert m.data['x1'].dtype == np.dtype('O')
m.add_data(y1=[1, 2])
assert m.data['y1'][()].shape == (2,)
def test_save_load_point_marker(self, mpl_cleanup):
x, y = 9, 8
color = 'purple'
name = "point test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_point_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_get_data_shape_point(self):
m0 = markers.point(5, 5)
m1 = markers.point((5, 10), (5, 10))
m2 = markers.point(((12, 2, 9), (1, 2, 3)), ((2, 5, 1), (3, 9, 2)))
m3 = markers.vertical_line(((12, 2), (2, 5), (9, 2)))
m4 = markers.point(5, 5)
m4.data['x1'][()] = np.array(None, dtype=np.object)
m4.data['y1'][()] = np.array(None, dtype=np.object)
m5 = markers.vertical_line(9)
m6 = markers.rectangle(1, 5, 6, 8)
m7 = markers.rectangle((1, 2), (5, 6), (6, 7), (8, 9))
m8 = markers.point(
np.arange(256).reshape(2, 2, 2, 2, 2, 2, 2, 2),
np.arange(256).reshape(2, 2, 2, 2, 2, 2, 2, 2))
assert m0._get_data_shape() == ()
assert m1._get_data_shape() == (2,)
assert m2._get_data_shape() == (2, 3)
assert m3._get_data_shape() == (3, 2)
with pytest.raises(ValueError):
assert m4._get_data_shape() == ()
assert m5._get_data_shape() == ()
assert m6._get_data_shape() == ()
assert m7._get_data_shape() == (2,)
assert m8._get_data_shape() == (2, 2, 2, 2, 2, 2, 2, 2)
def test_save_load_point_marker(self):
x, y = 9, 8
color = 'purple'
name = "point test"
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(
x=x, y=y, color=color)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_point_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 get_point_list(points: Union[list, np.ndarray], **kwargs) -> list:
"""Return a list of point markers.
Parameters
----------
points :
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.point`.
"""
points = np.atleast_2d(points)
return [point(x=x, y=y, **kwargs) for x, y in points]
def test_save_load_permanent_marker(self, tmp_path, file):
filename = tmp_path / file
s = self.s
x, y = 5, 2
color = 'red'
size = 10
name = 'testname'
m = markers.point(x=x, y=y, color=color, size=size)
m.name = name
s.add_marker(m, permanent=True)
s.save(filename)
s1 = load(filename)
assert s1.metadata.Markers.has_item(name)
m1 = s1.metadata.Markers.get_item(name)
assert m1.get_data_position('x1') == x
assert m1.get_data_position('y1') == y
assert m1.get_data_position('size') == size
assert m1.marker_properties['color'] == color
assert m1.name == name
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_save_load_permanent_marker(self):
x, y = 5, 2
color = 'red'
size = 10
name = 'testname'
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color, size=size)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testloadfile.hdf5'
s.save(filename)
s1 = load(filename)
assert s1.metadata.Markers.has_item(name)
m1 = s1.metadata.Markers.get_item(name)
assert m1.get_data_position('x1') == x
assert m1.get_data_position('y1') == y
assert m1.get_data_position('size') == size
assert m1.marker_properties['color'] == color
assert m1.name == name
def test_save_load_permanent_marker(self):
x, y = 5, 2
color = 'red'
size = 10
name = 'testname'
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=x, y=y, color=color, size=size)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/testloadfile.hdf5'
s.save(filename)
s1 = load(filename)
assert s1.metadata.Markers.has_item(name)
m1 = s1.metadata.Markers.get_item(name)
assert m1.get_data_position('x1') == x
assert m1.get_data_position('y1') == y
assert m1.get_data_position('size') == size
assert m1.marker_properties['color'] == color
assert m1.name == name
def test_save_load_multidim_navigation_marker(self):
x, y = (1, 2, 3), (5, 6, 7)
name = 'test point'
s = Signal2D(np.arange(300).reshape(3, 10, 10))
m = markers.point(x=x, y=y)
m.name = name
s.add_marker(m, permanent=True)
with tempfile.TemporaryDirectory() as tmp:
filename = tmp + '/test_save_multidim_nav_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())
assert m1.get_data_position('x1') == x[0]
assert m1.get_data_position('y1') == y[0]
s1.axes_manager.navigation_axes[0].index = 1
assert m1.get_data_position('x1') == x[1]
assert m1.get_data_position('y1') == y[1]
s1.axes_manager.navigation_axes[0].index = 2
assert m1.get_data_position('x1') == x[2]
assert m1.get_data_position('y1') == y[2]
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 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_add_permanent_marker_signal2d(self):
s = Signal2D(np.arange(100).reshape(10, 10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True)
assert list(s.metadata.Markers)[0][1] == m
def test_add_permanent_marker_not_plot(self):
s = Signal1D(np.arange(10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True, plot_marker=False)
assert list(s.metadata.Markers)[0][1] == m
def test_add_markers_as_list(self):
s = Signal1D(np.arange(10))
marker_list = []
for i in range(12):
marker_list.append(markers.point(4, 8))
s.add_marker(marker_list)
def test_add_permanent_marker_twice(self):
s = Signal1D(np.arange(10))
m = markers.point(x=5, y=5)
s.add_marker(m, permanent=True)
with pytest.raises(ValueError):
s.add_marker(m, permanent=True)
def test_add_marker_not_plot(self):
# This will do nothing, since plot_marker=False and permanent=False
# So this test will return a _logger warning
s = Signal1D(np.arange(10))
m = markers.point(x=5, y=5)
s.add_marker(m, plot_marker=False)
