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 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)
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))
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.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.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()