def reconstruct_object(flags, value):
""" Reconstructs the value (if necessary) after having saved it in a
dictionary
"""
if not isinstance(flags, list):
flags = parse_flag_string(flags)
if 'sig' in flags:
if isinstance(value, dict):
from hyperspy.signal import Signal
value = Signal(**value)
value._assign_subclass()
return value
if 'fn' in flags:
ifdill, thing = value
if ifdill is None:
return thing
if ifdill in [False, 'False']:
return types.FunctionType(marshal.loads(thing), globals())
if ifdill in [True, 'True']:
if not dill_avail:
raise ValueError("the dictionary was constructed using "
"\"dill\" package, which is not available on the system")
else:
return dill.loads(thing)
# should not be reached
raise ValueError("The object format is not recognized")
return value
def setUp(self):
self.signal = Signal(np.arange(2 * 4 * 6).reshape(2, 4, 6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_signal_iterator():
s = Signal(np.arange(3).reshape((3, 1)))
assert_equal(s.next().data[0], 0)
# If the following fails it can be because the iteration index was not
# restarted
for i, signal in enumerate(s):
assert_equal(i, signal.data[0])
def reconstruct_object(flags, value):
""" Reconstructs the value (if necessary) after having saved it in a
dictionary
"""
if not isinstance(flags, list):
flags = parse_flag_string(flags)
if 'sig' in flags:
if isinstance(value, dict):
from hyperspy.signal import Signal
value = Signal(**value)
value._assign_subclass()
return value
if 'fn' in flags:
ifdill, thing = value
if ifdill is None:
return thing
if ifdill in [False, 'False']:
return types.FunctionType(marshal.loads(thing), globals())
if ifdill in [True, 'True']:
if not dill_avail:
raise ValueError(
"the dictionary was constructed using "
"\"dill\" package, which is not available on the system")
else:
return dill.loads(thing)
# should not be reached
raise ValueError("The object format is not recognized")
return value
class Test3d():
def setUp(self):
self.s = Signal(np.random.random((2, 3, 4)))
def test_as_image_contigous(self):
assert_true(self.s.as_image((0, 1)).data.flags['C_CONTIGUOUS'])
def test_as_image_1(self):
assert_equal(self.s.as_image((0, 1)).data.shape, (4, 2, 3))
def test_as_image_2(self):
assert_equal(self.s.as_image((1, 0)).data.shape, (4, 3, 2))
def test_as_image_3(self):
assert_equal(self.s.as_image((1, 2)).data.shape, (3, 4, 2))
def test_as_spectrum_contigous(self):
assert_true(self.s.as_spectrum(0).data.flags['C_CONTIGUOUS'])
def test_as_spectrum_0(self):
assert_equal(self.s.as_spectrum(0).data.shape, (2, 4, 3))
def test_as_spectrum_1(self):
assert_equal(self.s.as_spectrum(1).data.shape, (3, 4, 2))
def test_as_spectrum_2(self):
assert_equal(self.s.as_spectrum(1).data.shape, (3, 4, 2))
def test_as_spectrum_3(self):
assert_equal(self.s.as_spectrum(2).data.shape, (2, 3, 4))
def test_remove_axis(self):
im = self.s.as_image((-2, -1))
im._remove_axis(-1)
assert_true(isinstance(im, signals.Spectrum))
class Test2d:
def setUp(self):
self.s = Signal(np.random.random((2, 3)))
def test_as_image_T(self):
assert_true(
self.s.data.T.shape == self.s.as_image((0, 1)).data.shape)
def test_as_image(self):
assert_true(
self.s.data.shape == self.s.as_image((1, 0)).data.shape)
def test_as_spectrum_T(self):
assert_true(
self.s.data.T.shape == self.s.as_spectrum(0).data.shape)
def test_as_spectrum(self):
assert_true(
self.s.data.shape == self.s.as_spectrum(1).data.shape)
def test_s2EELS2im2s(self):
s = self.s.as_spectrum(0)
s.set_signal_type("EELS")
im = s.as_image((1, 0))
assert_equal(im.metadata.Signal.signal_type, "EELS")
s = im.as_spectrum(0)
assert_equal(s.metadata.Signal.signal_type, "EELS")
assert_true(isinstance(s, signals.EELSSpectrum))
def test_signal_iterator():
s = Signal(np.arange(3).reshape((3, 1)))
nt.assert_equal(s.next().data[0], 0)
# If the following fails it can be because the iteration index was not
# restarted
for i, signal in enumerate(s):
nt.assert_equal(i, signal.data[0])
class Test2d():
def setUp(self):
self.s = Signal(np.random.random((2,3)))
def test_as_image_T(self):
assert_true(
self.s.data.T.shape == self.s.as_image((0,1)).data.shape)
def test_as_image(self):
assert_true(
self.s.data.shape == self.s.as_image((1,0)).data.shape)
def test_as_spectrum_T(self):
assert_true(
self.s.data.T.shape == self.s.as_spectrum(0).data.shape)
def test_as_spectrum(self):
assert_true(
self.s.data.shape == self.s.as_spectrum(1).data.shape)
def test_s2EELS2im2s(self):
s = self.s.as_spectrum(0)
s.set_signal_type("EELS")
im = s.as_image((1, 0))
assert_equal(im.mapped_parameters.signal_type, "EELS")
s = im.as_spectrum((0))
assert_equal(s.mapped_parameters.signal_type, "EELS")
assert_true(isinstance(s, signals.EELSSpectrum))
def setUp(self):
self.signal = Signal(np.arange(5*10).reshape(5,10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.signal.mapped_parameters.set_item('splitting.axis', 0)
self.signal.mapped_parameters.set_item(
'splitting.step_sizes',[2,2])
self.data = self.signal.data.copy()
def setUp(self):
s = Signal(np.empty((5, 5, 5)))
s.save("tmp.hdf5")
self.shape = (10000, 10000, 100)
del s
f = h5py.File("tmp.hdf5", model="r+")
s = f["Experiments/__unnamed__"]
del s["data"]
s.create_dataset("data", shape=self.shape, dtype="float64", chunks=True)
f.close()
def test_add_signal_in_dictionary(self):
tree = self.tree
s = Signal([1.0, 2, 3])
s.axes_manager[0].name = "x"
s.axes_manager[0].units = "ly"
tree.add_dictionary({"_sig_signal name": s._to_dictionary()})
nose.tools.assert_is_instance(tree.signal_name, Signal)
np.testing.assert_array_equal(tree.signal_name.data, s.data)
nose.tools.assert_dict_equal(tree.signal_name.metadata.as_dictionary(), s.metadata.as_dictionary())
nose.tools.assert_equal(tree.signal_name.axes_manager._get_axes_dicts(), s.axes_manager._get_axes_dicts())
class Test2D:
def setUp(self):
self.signal = Signal(np.arange(5*10).reshape(5,10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.signal.mapped_parameters.set_item('splitting.axis', 0)
self.signal.mapped_parameters.set_item(
'splitting.step_sizes',[2,2])
self.data = self.signal.data.copy()
def test_axis_by_str(self):
s1 = self.signal.deepcopy()
s2 = self.signal.deepcopy()
s1.crop(0, 2,4)
s2.crop("x", 2, 4)
assert_true((s1.data==s2.data).all())
def test_crop_int(self):
s = self.signal
d = self.data
s.crop(0, 2,4)
assert_true((s.data==d[2:4,:]).all())
def test_crop_float(self):
s = self.signal
d = self.data
s.crop(0, 2, 2.)
assert_true((s.data==d[2:4,:]).all())
def test_split_axis0(self):
result = self.signal.split(0,2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:2,:]).all())
assert_true((result[1].data == self.data[2:4,:]).all())
def test_split_axis1(self):
result = self.signal.split(1,2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:,:5]).all())
assert_true((result[1].data == self.data[:,5:]).all())
def test_split_axisE(self):
result = self.signal.split("E",2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:,:5]).all())
assert_true((result[1].data == self.data[:,5:]).all())
def test_split_default(self):
result = self.signal.split()
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:2,:]).all())
assert_true((result[1].data == self.data[2:4,:]).all())
def _spikes_diagnosis(self, signal_mask=None,
navigation_mask=None):
"""Plots a histogram to help in choosing the threshold for
spikes removal.
Parameters
----------
signal_mask: boolean array
Restricts the operation to the signal locations not marked
as True (masked)
navigation_mask: boolean array
Restricts the operation to the navigation locations not
marked as True (masked).
See also
--------
spikes_removal_tool
"""
self._check_signal_dimension_equals_one()
dc = self.data
if signal_mask is not None:
dc = dc[..., ~signal_mask]
if navigation_mask is not None:
dc = dc[~navigation_mask, :]
der = np.abs(np.diff(dc, 1, -1))
n = ((~navigation_mask).sum() if navigation_mask else
self.axes_manager.navigation_size)
# arbitrary cutoff for number of spectra necessary before histogram
# data is compressed by finding maxima of each spectrum
tmp = Signal(der) if n < 2000 else Signal(np.ravel(der.max(-1)))
# get histogram signal using smart binning and plot
tmph = tmp.get_histogram()
tmph.plot()
# Customize plot appearance
plt.gca().set_title('')
plt.gca().fill_between(tmph.axes_manager[0].axis,
tmph.data,
facecolor='#fddbc7',
interpolate=True,
color='none')
ax = tmph._plot.signal_plot.ax
axl = tmph._plot.signal_plot.ax_lines[0]
axl.set_line_properties(color='#b2182b')
plt.xlabel('Derivative magnitude')
plt.ylabel('Log(Counts)')
ax.set_yscale('log')
ax.set_ylim(10 ** -1, plt.ylim()[1])
ax.set_xlim(plt.xlim()[0], 1.1 * plt.xlim()[1])
plt.draw()
def _spikes_diagnosis(self, signal_mask=None, navigation_mask=None):
"""Plots a histogram to help in choosing the threshold for
spikes removal.
Parameters
----------
signal_mask: boolean array
Restricts the operation to the signal locations not marked
as True (masked)
navigation_mask: boolean array
Restricts the operation to the navigation locations not
marked as True (masked).
See also
--------
spikes_removal_tool
"""
self._check_signal_dimension_equals_one()
dc = self.data
if signal_mask is not None:
dc = dc[..., ~signal_mask]
if navigation_mask is not None:
dc = dc[~navigation_mask, :]
der = np.abs(np.diff(dc, 1, -1))
n = ((~navigation_mask).sum()
if navigation_mask else self.axes_manager.navigation_size)
# arbitrary cutoff for number of spectra necessary before histogram
# data is compressed by finding maxima of each spectrum
tmp = Signal(der) if n < 2000 else Signal(np.ravel(der.max(-1)))
# get histogram signal using smart binning and plot
tmph = tmp.get_histogram()
tmph.plot()
# Customize plot appearance
plt.gca().set_title('')
plt.gca().fill_between(tmph.axes_manager[0].axis,
tmph.data,
facecolor='#fddbc7',
interpolate=True,
color='none')
ax = tmph._plot.signal_plot.ax
axl = tmph._plot.signal_plot.ax_lines[0]
axl.set_line_properties(color='#b2182b')
plt.xlabel('Derivative magnitude')
plt.ylabel('Log(Counts)')
ax.set_yscale('log')
ax.set_ylim(10**-1, plt.ylim()[1])
ax.set_xlim(plt.xlim()[0], 1.1 * plt.xlim()[1])
plt.draw()
def test_add_signal_in_dictionary(self):
tree = self.tree
s = Signal([1., 2, 3])
s.axes_manager[0].name = 'x'
s.axes_manager[0].units = 'ly'
tree.add_dictionary({"_sig_signal name": s._to_dictionary()})
nose.tools.assert_is_instance(tree.signal_name, Signal)
nose.tools.assert_true(np.all(tree.signal_name.data == s.data))
nose.tools.assert_equal(tree.signal_name.metadata.as_dictionary(),
s.metadata.as_dictionary())
nose.tools.assert_equal(
tree.signal_name.axes_manager._get_axes_dicts(),
s.axes_manager._get_axes_dicts())
def setUp(self):
s = Signal(np.empty((5, 5, 5)))
s.save('tmp.hdf5', overwrite=True)
self.shape = (10000, 10000, 100)
del s
f = h5py.File('tmp.hdf5', model='r+')
s = f['Experiments/__unnamed__']
del s['data']
s.create_dataset(
'data',
shape=self.shape,
dtype='float64',
chunks=True)
f.close()
def as_signal(self, field='values'):
"""Get a parameter map as a signal object.
Please note that this method only works when the navigation
dimension is greater than 0.
Parameters
----------
field : {'values', 'std', 'is_set'}
Raises
------
NavigationDimensionError : if the navigation dimension is 0
"""
from hyperspy.signal import Signal
if self._axes_manager.navigation_dimension == 0:
raise NavigationDimensionError(0, '>0')
s = Signal(data=self.map[field],
axes=self._axes_manager._get_navigation_axes_dicts())
if self.component.active_is_multidimensional:
s.data[np.logical_not(self.component._active_array)] = np.nan
s.metadata.General.title = ("%s parameter" %
self.name if self.component is None else
"%s parameter of %s component" %
(self.name, self.component.name))
for axis in s.axes_manager._axes:
axis.navigate = False
if self._number_of_elements > 1:
s.axes_manager.append_axis(size=self._number_of_elements,
name=self.name,
navigate=True)
return s
class Test1d():
def setUp(self):
self.s = Signal(np.arange(2))
@raises(DataDimensionError)
def test_as_image(self):
assert_true((self.s.data == self.s.as_image((0,1)).data).all())
def test_as_spectrum(self):
assert_true((self.s.data == self.s.as_spectrum(0).data).all())
def test_set_EELS(self):
s = self.s.as_spectrum(0)
s.set_signal_type("EELS")
assert_equal(s.mapped_parameters.signal_type, "EELS")
assert_true(isinstance(s, signals.EELSSpectrum))
class Test3D_Navigate_1:
def setUp(self):
self.signal = Signal(np.arange(24).reshape((2, 3, 4)))
self.data = self.signal.data.copy()
self.signal.axes_manager._axes[0].navigate = False
self.signal.axes_manager._axes[1].navigate = True
self.signal.axes_manager._axes[2].navigate = False
def test_1px_navigation_indexer_slice(self):
s = self.signal.inav[1:2]
d = self.data[:, 1:2]
np.testing.assert_array_equal(s.data, d)
assert_equal(s.axes_manager._axes[1].offset, 1)
assert_equal(s.axes_manager._axes[1].size, 1)
assert_equal(s.axes_manager._axes[1].scale,
self.signal.axes_manager._axes[1].scale)
def test_1px_signal_indexer_slice(self):
s = self.signal.isig[1:2]
d = self.data[:, :, 1:2]
np.testing.assert_array_equal(s.data, d)
assert_equal(s.axes_manager.signal_axes[0].offset, 1)
assert_equal(s.axes_manager.signal_axes[0].size, 1)
assert_equal(s.axes_manager.signal_axes[0].scale,
self.signal.axes_manager.signal_axes[0].scale)
def test_subclass_assignment(self):
im = self.signal.as_image((-2, -1))
assert_true(isinstance(im.isig[0], signals.Spectrum))
class Test3D_Navigate_1:
def setUp(self):
self.signal = Signal(np.arange(24).reshape((2, 3, 4)))
self.data = self.signal.data.copy()
self.signal.axes_manager._axes[0].navigate = False
self.signal.axes_manager._axes[1].navigate = True
self.signal.axes_manager._axes[2].navigate = False
def test_1px_navigation_indexer_slice(self):
s = self.signal.inav[1:2]
d = self.data[:, 1:2]
assert_true((s.data == d).all())
assert_equal(s.axes_manager._axes[1].offset, 1)
assert_equal(s.axes_manager._axes[1].size, 1)
assert_equal(s.axes_manager._axes[1].scale,
self.signal.axes_manager._axes[1].scale)
def test_1px_signal_indexer_slice(self):
s = self.signal.isig[1:2]
d = self.data[:, :, 1:2]
assert_true((s.data == d).all())
assert_equal(s.axes_manager.signal_axes[0].offset, 1)
assert_equal(s.axes_manager.signal_axes[0].size, 1)
assert_equal(s.axes_manager.signal_axes[0].scale,
self.signal.axes_manager.signal_axes[0].scale)
def test_subclass_assignment(self):
im = self.signal.as_image((-2, -1))
assert_true(isinstance(im.isig[0], signals.Spectrum))
def setUp(self):
self.signal = Signal(np.arange(2 * 4 * 6).reshape(2, 4, 6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def as_signal(self, field='values'):
"""Get a parameter map as a signal object.
Please note that this method only works when the navigation
dimension is greater than 0.
Parameters
----------
field : {'values', 'std', 'is_set'}
Raises
------
NavigationDimensionError : if the navigation dimension is 0
"""
from hyperspy.signal import Signal
if self._axes_manager.navigation_dimension == 0:
raise NavigationDimensionError(0, '>0')
s = Signal(data=self.map[field],
axes=self._axes_manager._get_navigation_axes_dicts())
s.metadata.General.title = self.name
for axis in s.axes_manager._axes:
axis.navigate = False
if self._number_of_elements > 1:
s.axes_manager.append_axis(size=self._number_of_elements,
name=self.name,
navigate=True)
return s
def setUp(self):
s = Signal(np.ones((3, 2, 5)))
s.axes_manager[0].name = "x"
s.axes_manager[1].name = "y"
s.axes_manager[2].name = "E"
s.axes_manager[2].scale = 0.5
s.metadata.General.title = 'test'
self.signal = s
class TestSignalVarianceFolding:
def setUp(self):
self.s = Signal(np.empty((2, 3, 4, 5)))
self.s.axes_manager.set_signal_dimension(2)
self.s.estimate_poissonian_noise_variance()
def test_unfold_navigation(self):
s = self.s.deepcopy()
s.unfold_navigation_space()
meta_am = s.metadata.Signal.Noise_properties.variance.axes_manager
nose.tools.assert_equal(meta_am.navigation_shape, (self.s.axes_manager.navigation_size,))
def test_unfold_signal(self):
s = self.s.deepcopy()
s.unfold_signal_space()
meta_am = s.metadata.Signal.Noise_properties.variance.axes_manager
nose.tools.assert_equal(meta_am.signal_shape, (self.s.axes_manager.signal_size,))
class Test1d:
def setUp(self):
self.s = Signal(np.arange(2))
@nt.raises(DataDimensionError)
def test_as_image(self):
self.s.as_image((0, 1))
def test_as_spectrum(self):
np.testing.assert_array_equal(self.s.data, self.s.as_spectrum(0).data)
def test_set_EELS(self):
s = self.s.as_spectrum(0)
s.set_signal_type("EELS")
nt.assert_equal(s.metadata.Signal.signal_type, "EELS")
nt.assert_is_instance(s, signals.EELSSpectrum)
def test_signal_to_dictionary(self):
tree = self.tree
s = Signal([1., 2, 3])
s.axes_manager[0].name = 'x'
s.axes_manager[0].units = 'ly'
tree.set_item('Some name', s)
d = tree.as_dictionary()
nose.tools.assert_true(np.all(d['_sig_Some name']['data'] == s.data))
d['_sig_Some name']['data'] = 0
nose.tools.assert_equal(
{
"Node1": {
"leaf11": 11,
"Node11": {
"leaf111": 111
},
},
"Node2": {
"leaf21": 21,
"Node21": {
"leaf211": 211
},
},
"_sig_Some name": {
'axes': [{
'name': 'x',
'navigate': False,
'offset': 0.0,
'scale': 1.0,
'size': 3,
'units': 'ly'
}],
'data':
0,
'learning_results': {},
'metadata': {
'General': {
'title': ''
},
'Signal': {
'binned': False,
'record_by': '',
'signal_origin': '',
'signal_type': ''
},
'_HyperSpy': {
'Folding': {
'original_axes_manager': None,
'original_shape': None,
'unfolded': False,
'signal_unfolded': False
}
}
},
'original_metadata': {},
'tmp_parameters': {}
}
}, d)
class TestSignalFolding:
def setUp(self):
self.s = Signal(np.empty((2, 3, 4, 5)))
self.s.axes_manager.set_signal_dimension(2)
def test_unfold_navigation(self):
s = self.s.deepcopy()
s.unfold_navigation_space()
nose.tools.assert_equal(s.axes_manager.navigation_shape, (self.s.axes_manager.navigation_size,))
def test_unfold_signal(self):
s = self.s.deepcopy()
s.unfold_signal_space()
nose.tools.assert_equal(s.axes_manager.signal_shape, (self.s.axes_manager.signal_size,))
def test_unfolded_repr(self):
self.s.unfold()
nose.tools.assert_true("unfolded" in repr(self.s))
def test_general_type_not_working(self):
s = self.s
s.metadata.set_item('test', (Signal([1]), 0.1, 'test_string'))
s.save('tmp.hdf5', overwrite=True)
l = load('tmp.hdf5')
nt.assert_is_instance(l.metadata.test, tuple)
nt.assert_is_instance(l.metadata.test[0], Signal)
nt.assert_is_instance(l.metadata.test[1], float)
nt.assert_is_instance(l.metadata.test[2], unicode)
def setUp(self):
self.signal = Signal(np.arange(5*10).reshape(5,10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.signal.mapped_parameters.set_item('splitting.axis', 0)
self.signal.mapped_parameters.set_item(
'splitting.step_sizes',[2,2])
self.data = self.signal.data.copy()
class TestSignalVarianceFolding:
def setUp(self):
self.s = Signal(np.empty((2, 3, 4, 5)))
self.s.axes_manager.set_signal_dimension(2)
self.s.estimate_poissonian_noise_variance()
def test_unfold_navigation(self):
s = self.s.deepcopy()
s.unfold_navigation_space()
nose.tools.assert_equal(s.metadata.Signal.Noise_properties.variance.axes_manager.navigation_shape,
(self.s.axes_manager.navigation_size,))
def test_unfold_signal(self):
s = self.s.deepcopy()
s.unfold_signal_space()
nose.tools.assert_equal(s.metadata.Signal.Noise_properties.variance.axes_manager.signal_shape,
(self.s.axes_manager.signal_size,))
class Test3d:
def setUp(self):
self.s = Signal(np.random.random((2, 3, 4)))
def test_as_image_contigous(self):
assert_true(self.s.as_image((0, 1)).data.flags['C_CONTIGUOUS'])
def test_as_image_1(self):
assert_equal(
self.s.as_image((0, 1)).data.shape, (4, 2, 3))
def test_as_image_2(self):
assert_equal(
self.s.as_image((1, 0)).data.shape, (4, 3, 2))
def test_as_image_3(self):
assert_equal(
self.s.as_image((1, 2)).data.shape, (3, 4, 2))
def test_as_spectrum_contigous(self):
assert_true(self.s.as_spectrum(0).data.flags['C_CONTIGUOUS'])
def test_as_spectrum_0(self):
assert_equal(
self.s.as_spectrum(0).data.shape, (2, 4, 3))
def test_as_spectrum_1(self):
assert_equal(
self.s.as_spectrum(1).data.shape, (3, 4, 2))
def test_as_spectrum_2(self):
assert_equal(
self.s.as_spectrum(1).data.shape, (3, 4, 2))
def test_as_spectrum_3(self):
assert_equal(
self.s.as_spectrum(2).data.shape, (2, 3, 4))
def test_remove_axis(self):
im = self.s.as_image((-2, -1))
im._remove_axis(-1)
assert_true(isinstance(im, signals.Spectrum))
class TestSignalFolding:
def setUp(self):
self.s = Signal(np.empty((2, 3, 4, 5)))
self.s.axes_manager.set_signal_dimension(2)
def test_unfold_navigation(self):
s = self.s.deepcopy()
s.unfold_navigation_space()
nose.tools.assert_equal(s.axes_manager.navigation_shape,
(self.s.axes_manager.navigation_size,))
def test_unfold_signal(self):
s = self.s.deepcopy()
s.unfold_signal_space()
nose.tools.assert_equal(s.axes_manager.signal_shape,
(self.s.axes_manager.signal_size,))
def test_unfolded_repr(self):
self.s.unfold()
nose.tools.assert_true("unfolded" in repr(self.s))
def reconstruct_object(flags, value):
""" Reconstructs the value (if necessary) after having saved it in a
dictionary
"""
if not isinstance(flags, list):
flags = parse_flag_string(flags)
if "sig" in flags:
if isinstance(value, dict):
from hyperspy.signal import Signal
value = Signal(**value)
value._assign_subclass()
return value
if "fn" in flags:
ifdill, thing = value
if ifdill is None:
return thing
if ifdill in [True, "True", b"True"]:
return dill.loads(thing)
# should not be reached
raise ValueError("The object format is not recognized")
return value
def __setattr__(self, key, value):
if key.startswith('_sig_'):
key = key[5:]
from hyperspy.signal import Signal
value = Signal(**value)
slugified_key = str(slugify(key, valid_variable_name=True))
if isinstance(value, dict):
if self.has_item(slugified_key):
self.get_item(slugified_key).add_dictionary(value)
return
else:
value = DictionaryTreeBrowser(value)
super(DictionaryTreeBrowser, self).__setattr__(
slugified_key,
{'key': key, '_dtb_value_': value})
class Test3D:
def setUp(self):
self.signal = Signal(np.arange(2 * 4 * 6).reshape(2, 4, 6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_rebin(self):
assert_true(self.signal.rebin((2, 1, 6)).data.shape == (1, 2, 6))
def test_swap_axes(self):
s = self.signal
assert_equal(s.swap_axes(0, 1).data.shape, (4, 2, 6))
assert_true(s.swap_axes(0, 2).data.flags['C_CONTIGUOUS'])
class Test3D:
def setUp(self):
self.signal = Signal(np.arange(2 * 4 * 6).reshape(2, 4, 6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_rebin(self):
assert_true(self.signal.rebin((2, 1, 6)).data.shape == (1, 2, 6))
def test_swap_axes(self):
s = self.signal
assert_equal(s.swap_axes(0, 1).data.shape, (4, 2, 6))
assert_true(s.swap_axes(0, 2).data.flags['C_CONTIGUOUS'])
class Test3D:
def setUp(self):
self.signal = Signal(np.arange(2*4*6).reshape(2,4,6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.signal.mapped_parameters.set_item('splitting.axis', 0)
self.signal.mapped_parameters.set_item(
'splitting.step_sizes',[2,2])
self.data = self.signal.data.copy()
def test_rebin(self):
assert_true(self.signal.rebin((2,1,6)).data.shape == (1,2,6))
def test_swap_axes(self):
s = self.signal
assert_equal(s.swap_axes(0,1).data.shape, (4,2,6))
assert_true(s.swap_axes(0,2).data.flags['C_CONTIGUOUS'])
class Test3D:
def setUp(self):
self.signal = Signal(np.arange(2*4*6).reshape(2,4,6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.signal.mapped_parameters.set_item('splitting.axis', 0)
self.signal.mapped_parameters.set_item(
'splitting.step_sizes',[2,2])
self.data = self.signal.data.copy()
def test_rebin(self):
assert_true(self.signal.rebin((2,1,6)).data.shape == (1,2,6))
def test_swap_axes(self):
s = self.signal
assert_equal(s.swap_axes(0,1).data.shape, (4,2,6))
assert_true(s.swap_axes(0,2).data.flags['C_CONTIGUOUS'])
def setUp(self):
s = Signal(np.empty((5, 5, 5)))
s.save('tmp.hdf5', overwrite=True)
self.shape = (10000, 10000, 100)
del s
f = h5py.File('tmp.hdf5', model='r+')
s = f['Experiments/__unnamed__']
del s['data']
s.create_dataset('data',
shape=self.shape,
dtype='float64',
chunks=True)
f.close()
class Test2D:
def setUp(self):
self.signal = Signal(np.arange(5 * 10).reshape(5, 10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_sum_x(self):
s = self.signal.sum("x")
np.testing.assert_array_equal(self.signal.data.sum(0), s.data)
nt.assert_equal(s.data.ndim, 1)
nt.assert_equal(s.axes_manager.navigation_dimension, 0)
def test_sum_x_E(self):
s = self.signal.sum(("x", "E"))
_verify_test_sum_x_E(self, s)
s = self.signal.sum((0, "E"))
_verify_test_sum_x_E(self, s)
s = self.signal.sum((self.signal.axes_manager[0], "E"))
_verify_test_sum_x_E(self, s)
s = self.signal.sum("x").sum("E")
_verify_test_sum_x_E(self, s)
def test_axis_by_str(self):
m = mock.Mock()
s1 = self.signal.deepcopy()
s1.events.data_changed.connect(m.data_changed)
s2 = self.signal.deepcopy()
s1.crop(0, 2, 4)
nt.assert_true(m.data_changed.called)
s2.crop("x", 2, 4)
nt.assert_true((s1.data == s2.data).all())
def test_crop_int(self):
s = self.signal
d = self.data
s.crop(0, 2, 4)
nt.assert_true((s.data == d[2:4, :]).all())
def test_crop_float(self):
s = self.signal
d = self.data
s.crop(0, 2, 2.)
nt.assert_true((s.data == d[2:4, :]).all())
def test_split_axis0(self):
result = self.signal.split(0, 2)
nt.assert_true(len(result) == 2)
nt.assert_true((result[0].data == self.data[:2, :]).all())
nt.assert_true((result[1].data == self.data[2:4, :]).all())
def test_split_axis1(self):
result = self.signal.split(1, 2)
nt.assert_true(len(result) == 2)
nt.assert_true((result[0].data == self.data[:, :5]).all())
nt.assert_true((result[1].data == self.data[:, 5:]).all())
def test_split_axisE(self):
result = self.signal.split("E", 2)
nt.assert_true(len(result) == 2)
nt.assert_true((result[0].data == self.data[:, :5]).all())
nt.assert_true((result[1].data == self.data[:, 5:]).all())
def test_split_default(self):
result = self.signal.split()
nt.assert_true(len(result) == 5)
nt.assert_true((result[0].data == self.data[0]).all())
def test_histogram(self):
result = self.signal.get_histogram(3)
nt.assert_true(isinstance(result, signals.Spectrum))
nt.assert_true((result.data == np.array([17, 16, 17])).all())
nt.assert_true(result.metadata.Signal.binned)
def test_estimate_poissonian_noise_copy_data(self):
self.signal.estimate_poissonian_noise_variance()
variance = self.signal.metadata.Signal.Noise_properties.variance
nt.assert_true(
variance.data is not self.signal.data)
def test_estimate_poissonian_noise_noarg(self):
self.signal.estimate_poissonian_noise_variance()
variance = self.signal.metadata.Signal.Noise_properties.variance
nt.assert_true((variance.data == self.signal.data).all())
def test_estimate_poissonian_noise_with_args(self):
self.signal.estimate_poissonian_noise_variance(
expected_value=self.signal,
gain_factor=2,
gain_offset=1,
correlation_factor=0.5)
variance = self.signal.metadata.Signal.Noise_properties.variance
nt.assert_true(
(variance.data == (self.signal.data * 2 + 1) * 0.5).all())
def test_unfold_image(self):
s = self.signal
s.axes_manager.set_signal_dimension(2)
s.unfold()
nt.assert_equal(s.data.shape, (50,))
def test_unfold_image_returns_true(self):
s = self.signal
s.axes_manager.set_signal_dimension(2)
nt.assert_true(s.unfold())
class Test2D:
def setUp(self):
self.signal = Signal(np.arange(5 * 10).reshape(5, 10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_axis_by_str(self):
s1 = self.signal.deepcopy()
s2 = self.signal.deepcopy()
s1.crop(0, 2, 4)
s2.crop("x", 2, 4)
assert_true((s1.data == s2.data).all())
def test_crop_int(self):
s = self.signal
d = self.data
s.crop(0, 2, 4)
assert_true((s.data == d[2:4, :]).all())
def test_crop_float(self):
s = self.signal
d = self.data
s.crop(0, 2, 2.)
assert_true((s.data == d[2:4, :]).all())
def test_split_axis0(self):
result = self.signal.split(0, 2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:2, :]).all())
assert_true((result[1].data == self.data[2:4, :]).all())
def test_split_axis1(self):
result = self.signal.split(1, 2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:, :5]).all())
assert_true((result[1].data == self.data[:, 5:]).all())
def test_split_axisE(self):
result = self.signal.split("E", 2)
assert_true(len(result) == 2)
assert_true((result[0].data == self.data[:, :5]).all())
assert_true((result[1].data == self.data[:, 5:]).all())
def test_split_default(self):
result = self.signal.split()
assert_true(len(result) == 5)
assert_true((result[0].data == self.data[0]).all())
def test_histogram(self):
result = self.signal.get_histogram(3)
assert_true(isinstance(result, signals.Spectrum))
assert_true((result.data == np.array([17, 16, 17])).all())
def test_estimate_poissonian_noise_copy_data(self):
self.signal.estimate_poissonian_noise_variance()
assert_true(self.signal.metadata.Signal.Noise_properties.variance.data
is not self.signal.data)
def test_estimate_poissonian_noise_noarg(self):
self.signal.estimate_poissonian_noise_variance()
assert_true(
(self.signal.metadata.Signal.Noise_properties.variance.data ==
self.signal.data).all())
def test_estimate_poissonian_noise_with_args(self):
self.signal.estimate_poissonian_noise_variance(
expected_value=self.signal,
gain_factor=2,
gain_offset=1,
correlation_factor=0.5)
assert_true(
(self.signal.metadata.Signal.Noise_properties.variance.data ==
(self.signal.data * 2 + 1) * 0.5).all())
def setUp(self):
self.s = Signal(np.arange(2))
def setUp(self):
self.signal = Signal(np.arange(24).reshape((2, 3, 4)))
self.data = self.signal.data.copy()
self.signal.axes_manager._axes[0].navigate = False
self.signal.axes_manager._axes[1].navigate = True
self.signal.axes_manager._axes[2].navigate = False
def __init__(self, *args, **kwargs):
Signal.__init__(self, *args, **kwargs)
self.axes_manager.set_view('spectrum')
def __init__(self, *args, **kwargs):
Signal.__init__(self, *args, **kwargs)
self.axes_manager.set_view('hyperspectrum')
def setUp(self):
self.gaussian = Gaussian()
self.gaussian._axes_manager = Signal(np.zeros((3, 3, 1))).axes_manager
def setUp(self):
self.s1 = Signal(np.ones((2, 3)))
self.s2 = Signal(np.ones((2, 3)))
self.s2.data *= 2
class TestBinaryOperators:
def setUp(self):
self.s1 = Signal(np.ones((2, 3)))
self.s2 = Signal(np.ones((2, 3)))
self.s2.data *= 2
def test_sum_same_shape_signals(self):
s = self.s1 + self.s2
assert_array_equal(s.data, self.s1.data * 3)
def test_sum_in_place_same_shape_signals(self):
s1 = self.s1
self.s1 += self.s2
assert_array_equal(self.s1.data, np.ones((2, 3)) * 3)
nt.assert_is(s1, self.s1)
def test_sum_same_shape_signals_not_aligned(self):
s1 = self.s1
s2 = Signal(2 * np.ones((3, 2)))
s1.axes_manager._axes[0].navigate = False
s1.axes_manager._axes[1].navigate = True
s2.axes_manager._axes[1].navigate = False
s2.axes_manager._axes[0].navigate = True
s12 = s1 + s2
s21 = s2 + s1
assert_array_equal(s12.data, np.ones((3, 2)) * 3)
assert_array_equal(s21.data, s12.data)
def test_sum_in_place_same_shape_signals_not_aligned(self):
s1 = self.s1
s2 = Signal(2 * np.ones((3, 2)))
s1c = s1
s2c = s2
s1.axes_manager._axes[0].navigate = False
s1.axes_manager._axes[1].navigate = True
s2.axes_manager._axes[1].navigate = False
s2.axes_manager._axes[0].navigate = True
s1 += s2
assert_array_equal(s1.data, np.ones((3, 2)) * 3)
s2 += s2
assert_array_equal(s2.data, np.ones((3, 2)) * 4)
nt.assert_is(s1, s1c)
nt.assert_is(s2, s2c)
@nt.raises(ValueError)
def test_sum_wrong_shape(self):
s1 = self.s1
s2 = Signal(np.ones((3, 3)))
s1 + s2
def test_broadcast_missing_sig_and_nav(self):
s1 = self.s1
s2 = self.s2.as_image((1, 0)) # (|3, 2)
s1.axes_manager.set_signal_dimension(0) # (3, 2|)
s = s1 + s2
assert_array_equal(s.data, 3 * np.ones((2, 3, 2, 3)))
nt.assert_equal(s.metadata.Signal.record_by, "image")
def test_broadcast_missing_sig(self):
s1 = self.s1
s2 = self.s2
s1.axes_manager.set_signal_dimension(0) # (3, 2|)
s2.axes_manager._axes[1].navigate = True
s2.axes_manager._axes[0].navigate = False # (3| 2)
s12 = s1 + s2 # (3, 2| 2)
s21 = s2 + s1
assert_array_equal(s12.data, 3 * np.ones((2, 3, 2)))
assert_array_equal(s21.data, 3 * np.ones((2, 3, 2)))
@nt.raises(ValueError)
def test_broadcast_in_place_missing_sig_wrong(self):
s1 = self.s1
s2 = self.s2
s1.axes_manager.set_signal_dimension(0) # (3, 2|)
s2.axes_manager._axes[1].navigate = True
s2.axes_manager._axes[0].navigate = False # (3| 2)
s1 += s2
def test_broadcast_in_place(self):
s1 = self.s1
s1.axes_manager.set_signal_dimension(1) # (3|2)
s2 = Signal(np.ones((4, 2, 4, 3)))
s2c = s2
s2.axes_manager.set_signal_dimension(2) # (3, 4| 2, 4)
print(s2)
print(s1)
s2 += s1
assert_array_equal(s2.data, 2 * np.ones((4, 2, 4, 3)))
nt.assert_is(s2, s2c)
def test_equal_naxes_diff_shape(self):
s32 = self.s1 # (3| 2)
s31 = Signal(np.ones((1, 3)))
s12 = Signal(np.ones((2, 1)))
assert_array_equal((s32 + s31).data, s32.data + 1)
assert_array_equal((s32 + s12).data, s32.data + 1)
def __init__(self, *args, **kwargs):
Signal.__init__(self, *args, **kwargs)
self.axes_manager.set_signal_dimension(1)
def setUp(self):
self.s1 = Signal(np.arange(20).reshape(2, 2, 5))
self.s2 = Signal(np.arange(4).reshape(2, 2))
self.s2.axes_manager.set_signal_dimension(2)
self.s3 = Signal(np.arange(4).reshape(1, 2, 2))
self.s3.axes_manager.set_signal_dimension(2)
def setUp(self):
self.s1 = Signal(np.arange(6))
def setUp(self):
self.s = Signal(np.random.random((2, 3, 4)))
def setUp(self):
self.s1 = Signal(np.arange(10).reshape(2, 5))
self.s1.axes_manager.set_signal_dimension(2)
self.s2 = Signal(np.arange(6))
class Test3D:
def setUp(self):
self.signal = Signal(np.arange(2 * 4 * 6).reshape(2, 4, 6))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "y"
self.signal.axes_manager[2].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
def test_indexmax(self):
s = self.signal.indexmax('E')
ar = self.data.argmax(2)
np.testing.assert_array_equal(ar, s.data)
nt.assert_equal(s.data.ndim, 2)
nt.assert_equal(s.axes_manager.signal_dimension, 0)
nt.assert_equal(s.axes_manager.navigation_dimension, 2)
def test_valuemax(self):
s = self.signal.valuemax('x')
ar = self.signal.axes_manager['x'].index2value(self.data.argmax(1))
np.testing.assert_array_equal(ar, s.data)
nt.assert_equal(s.data.ndim, 2)
nt.assert_equal(s.axes_manager.signal_dimension, 1)
nt.assert_equal(s.axes_manager.navigation_dimension, 1)
def test_default_navigation_sum(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'sum')
def test_default_navigation_max(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'max')
def test_default_navigation_min(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'min')
def test_default_navigation_mean(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'mean')
def test_default_navigation_std(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'std')
def test_default_navigation_var(self):
_test_default_navigation_signal_operations_over_many_axes(self, 'var')
def test_rebin(self):
self.signal.estimate_poissonian_noise_variance()
new_s = self.signal.rebin((2, 1, 6))
var = new_s.metadata.Signal.Noise_properties.variance
nt.assert_true(new_s.data.shape == (1, 2, 6))
nt.assert_true(var.data.shape == (1, 2, 6))
from hyperspy.misc.array_tools import rebin
nt.assert_true(np.all(rebin(self.signal.data, (1, 2, 6)) == var.data))
nt.assert_true(
np.all(
rebin(
self.signal.data, (1, 2, 6)) == new_s.data))
@nt.raises(AttributeError)
def test_rebin_no_variance(self):
new_s = self.signal.rebin((2, 1, 6))
_ = new_s.metadata.Signal.Noise_properties
def test_rebin_const_variance(self):
self.signal.metadata.set_item('Signal.Noise_properties.variance', 0.3)
new_s = self.signal.rebin((2, 1, 6))
nt.assert_true(new_s.metadata.Signal.Noise_properties.variance == 0.3)
def test_swap_axes(self):
s = self.signal
nt.assert_equal(s.swap_axes(0, 1).data.shape, (4, 2, 6))
nt.assert_true(s.swap_axes(0, 2).data.flags['C_CONTIGUOUS'])
def test_get_navigation_signal_nav_dim0(self):
s = self.signal
s.axes_manager.set_signal_dimension(3)
ns = s._get_navigation_signal()
nt.assert_equal(ns.axes_manager.signal_dimension, 1)
nt.assert_equal(ns.axes_manager.signal_size, 1)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
def test_get_navigation_signal_nav_dim1(self):
s = self.signal
s.axes_manager.set_signal_dimension(2)
ns = s._get_navigation_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.navigation_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
def test_get_navigation_signal_nav_dim2(self):
s = self.signal
s.axes_manager.set_signal_dimension(1)
ns = s._get_navigation_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.navigation_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
def test_get_navigation_signal_nav_dim3(self):
s = self.signal
s.axes_manager.set_signal_dimension(0)
ns = s._get_navigation_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.navigation_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
@nt.raises(ValueError)
def test_get_navigation_signal_wrong_data_shape(self):
s = self.signal
s.axes_manager.set_signal_dimension(1)
s._get_navigation_signal(data=np.zeros((3, 2)))
@nt.raises(ValueError)
def test_get_navigation_signal_wrong_data_shape_dim0(self):
s = self.signal
s.axes_manager.set_signal_dimension(3)
s._get_navigation_signal(data=np.asarray(0))
def test_get_navigation_signal_given_data(self):
s = self.signal
s.axes_manager.set_signal_dimension(1)
data = np.zeros(s.axes_manager._navigation_shape_in_array)
ns = s._get_navigation_signal(data=data)
nt.assert_is(ns.data, data)
def test_get_signal_signal_nav_dim0(self):
s = self.signal
s.axes_manager.set_signal_dimension(0)
ns = s._get_signal_signal()
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
nt.assert_equal(ns.axes_manager.navigation_size, 0)
nt.assert_equal(ns.axes_manager.signal_dimension, 1)
def test_get_signal_signal_nav_dim1(self):
s = self.signal
s.axes_manager.set_signal_dimension(1)
ns = s._get_signal_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.signal_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
def test_get_signal_signal_nav_dim2(self):
s = self.signal
s.axes_manager.set_signal_dimension(2)
ns = s._get_signal_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.signal_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
def test_get_signal_signal_nav_dim3(self):
s = self.signal
s.axes_manager.set_signal_dimension(3)
ns = s._get_signal_signal()
nt.assert_equal(ns.axes_manager.signal_shape,
s.axes_manager.signal_shape)
nt.assert_equal(ns.axes_manager.navigation_dimension, 0)
@nt.raises(ValueError)
def test_get_signal_signal_wrong_data_shape(self):
s = self.signal
s.axes_manager.set_signal_dimension(1)
s._get_signal_signal(data=np.zeros((3, 2)))
@nt.raises(ValueError)
def test_get_signal_signal_wrong_data_shape_dim0(self):
s = self.signal
s.axes_manager.set_signal_dimension(0)
s._get_signal_signal(data=np.asarray(0))
def test_get_signal_signal_given_data(self):
s = self.signal
s.axes_manager.set_signal_dimension(2)
data = np.zeros(s.axes_manager._signal_shape_in_array)
ns = s._get_signal_signal(data=data)
nt.assert_is(ns.data, data)
def test_get_navigation_signal_dtype(self):
s = self.signal
nt.assert_equal(s._get_navigation_signal().data.dtype.name,
s.data.dtype.name)
def test_get_signal_signal_dtype(self):
s = self.signal
nt.assert_equal(s._get_signal_signal().data.dtype.name,
s.data.dtype.name)
def test_get_navigation_signal_given_dtype(self):
s = self.signal
nt.assert_equal(
s._get_navigation_signal(dtype="bool").data.dtype.name, "bool")
def test_get_signal_signal_given_dtype(self):
s = self.signal
nt.assert_equal(
s._get_signal_signal(dtype="bool").data.dtype.name, "bool")
def setUp(self):
self.s1 = Signal(np.array((1, -1, 4, -3)))
def setUp(self):
self.s = Signal(np.arange(2))
def setUp(self):
self.s1 = Signal(np.arange(20).reshape(2, 2, 5))
self.s2 = Signal(np.arange(5))
self.s3 = Signal(np.arange(5).reshape(1, 5))
def setUp(self):
self.signal = Signal(np.arange(5 * 10).reshape(5, 10))
self.signal.axes_manager[0].name = "x"
self.signal.axes_manager[1].name = "E"
self.signal.axes_manager[0].scale = 0.5
self.data = self.signal.data.copy()
