def __init__(self, *args, **kwargs): """Create an :class:`~kikuchipy.signals.EBSDMasterPattern` object from a :class:`hyperspy.signals.Signal2D` or a :class:`numpy.ndarray`. """ Signal2D.__init__(self, *args, **kwargs) self.phase = kwargs.pop("phase", Phase()) self.projection = kwargs.pop("projection", None) self.hemisphere = kwargs.pop("hemisphere", None)
def __init__(self, *args, **kwargs): """Create an :class:`~kikuchipy.signals.EBSDMasterPattern` instance from a :class:`hyperspy.signals.Signal2D` or a :class:`numpy.ndarray`. See the docstring of :class:`hyperspy.signal.BaseSignal` for optional input parameters. """ Signal2D.__init__(self, *args, **kwargs) self.phase = kwargs.pop("phase", Phase()) self.projection = kwargs.pop("projection", None) self.hemisphere = kwargs.pop("hemisphere", None)
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_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 __init__(self, *args, **kwargs): """Create an :class:`~kikuchipy.signals.EBSDMasterPattern` object from a :class:`hyperspy.signals.Signal2D` or a :class:`numpy.ndarray`. """ Signal2D.__init__(self, *args, **kwargs) # Update metadata if object is initialized from numpy array or # with set_signal_type() if not self.metadata.has_item(metadata_nodes("ebsd_master_pattern")): md = self.metadata.as_dictionary() md.update(ebsd_master_pattern_metadata().as_dictionary()) self.metadata = DictionaryTreeBrowser(md) if not self.metadata.has_item("Sample.Phases"): self.set_phase_parameters()
def setup_method(self, method): ics = np.random.laplace(size=(3, 1024)) np.random.seed(1) mixing_matrix = np.random.random((100, 3)) s = Signal2D(np.dot(mixing_matrix, ics).reshape((100, 32, 32))) for (axis, name) in zip(s.axes_manager._axes, ("z", "y", "x")): axis.name = name s.decomposition() self.s = s
def test_chunking_saving_lazy_specify(self, tmp_path, file): filename = tmp_path / file s = Signal2D(da.zeros((50, 100, 100))).as_lazy() # specify chunks chunks = (50, 10, 10) s.data = s.data.rechunk([50, 25, 25]) s.save(filename, chunks=chunks) s1 = load(filename, lazy=True) assert tuple([c[0] for c in s1.data.chunks]) == chunks
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 get_diffraction( self, convergence_angle=.74, accelerating_voltage=200, k_rad=5.0, simulation_size=(256, 256), noise=False, num_electrons=1000, ): """Returns an amorphous2d Diffraction pattern based on the clusters in one column. Parameters ------------ convergence_angle: float The convergence angle for the experiment accelerating_voltage: float The accelerating voltage for the experiment in kV simulation_size: tuple The size of the image for both the reciporical space image and the real space image. Returns ------------ dataset: Amorphus2D Returns a 4 dimensional dataset which represents the cube """ # dataset = Signal2D(np.ones(simulation_size)) dataset = np.ones(simulation_size) for cluster in self: speckles, observed_intensity = cluster.get_speckles( img_size=k_rad * 2, num_pixels=simulation_size[0], accelerating_voltage=accelerating_voltage, conv_angle=convergence_angle) print(cluster) for (sr, sc), inten in zip(speckles, observed_intensity): dataset[sr, sc] = dataset[sr, sc] + inten if noise: dataset = dataset * num_electrons noise = np.random.poisson(dataset) dataset = dataset + noise else: dataset = dataset * num_electrons dataset = Signal2D(dataset) dataset.axes_manager.signal_axes[ 0].scale = k_rad * 2 / simulation_size[0] dataset.axes_manager.signal_axes[ 1].scale = k_rad * 2 / simulation_size[1] dataset.axes_manager.signal_axes[0].units = "$nm^-1$" dataset.axes_manager.signal_axes[1].units = "$nm^-1$" dataset.axes_manager.signal_axes[0].offset = -k_rad dataset.axes_manager.signal_axes[1].offset = -k_rad return dataset
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_save_load_text_marker(self): x, y = 3, 9.5 color = 'brown' name = "text_test" text = "a text" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.text(x=x, y=y, text=text, color=color) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_text_marker.hdf5' s.save(filename) s1 = load(filename) m1 = s1.metadata.Markers.get_item(name) assert san_dict(m1._to_dictionary()) == san_dict(m._to_dictionary())
def test_save_load_horizontal_line_marker(self, mpl_cleanup): y = 8 color = 'blue' linewidth = 2.5 name = "horizontal_line_test" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.horizontal_line(y=y, color=color, linewidth=linewidth) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_horizontal_line_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_save_hyperspy_signal_metadata(self, tmp_path): s = self.s s.original_metadata.set_item("testarray1", BaseSignal([1.2, 2.3, 3.4])) s.original_metadata.set_item("testarray2", (1, 2, 3, 4, 5)) s.original_metadata.set_item("testarray3", Signal2D(np.ones((2, 3, 5, 4)))) fname = tmp_path / 'test.nxs' s.save(fname) lin = load(fname, nxdata_only=True) np.testing.assert_allclose(lin.original_metadata.testarray1.data, np.array([1.2, 2.3, 3.4])) np.testing.assert_array_equal(lin.original_metadata.testarray2, np.array([1, 2, 3, 4, 5])) np.testing.assert_array_equal(lin.original_metadata.testarray3.data, np.ones((2, 3, 5, 4)))
def test_save_load_vertical_line_marker(self): x = 9 color = 'black' linewidth = 3.5 name = "vertical_line_test" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.vertical_line(x=x, color=color, linewidth=linewidth) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_vertical_line_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_save_load_line_segment_marker(self, mpl_cleanup): x1, x2, y1, y2 = 1, 9, 4, 7 color = 'cyan' linewidth = 0.7 name = "line_segment_test" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.line_segment( x1=x1, x2=x2, y1=y1, y2=y2, color=color, linewidth=linewidth) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_line_segment_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_save_load_horizontal_line_segment_marker(self): x1, x2, y = 1, 5, 8 color = 'red' linewidth = 1.2 name = "horizontal_line_segment_test" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.horizontal_line_segment( x1=x1, x2=x2, y=y, color=color, linewidth=linewidth) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_horizontal_line_segment_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_save_load_rectangle_marker(self): x1, x2, y1, y2 = 2, 4, 1, 3 color = 'yellow' linewidth = 5 name = "rectangle_test" s = Signal2D(np.arange(100).reshape(10, 10)) m = markers.rectangle( x1=x1, x2=x2, y1=y1, y2=y2, color=color, linewidth=linewidth) m.name = name s.add_marker(m, permanent=True) with tempfile.TemporaryDirectory() as tmp: filename = tmp + '/test_save_rectangle_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_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_chunking_saving_lazy(): s = Signal2D(da.zeros((50, 100, 100))).as_lazy() s.data = s.data.rechunk([50, 25, 25]) with tempfile.TemporaryDirectory() as tmp: filename = os.path.join(tmp, 'test_chunking_saving_lazy.hspy') filename2 = os.path.join(tmp, 'test_chunking_saving_lazy_chunks_True.hspy') filename3 = os.path.join(tmp, 'test_chunking_saving_lazy_chunks_specified.hspy') s.save(filename) s1 = load(filename, lazy=True) assert s.data.chunks == s1.data.chunks # with chunks=True, use h5py chunking s.save(filename2, chunks=True) s2 = load(filename2, lazy=True) assert tuple([c[0] for c in s2.data.chunks]) == (7, 25, 25) # specify chunks chunks = (50, 10, 10) s.save(filename3, chunks=chunks) s3 = load(filename3, lazy=True) assert tuple([c[0] for c in s3.data.chunks]) == chunks
def test_chunking_saving_lazy(tmp_path, file): s = Signal2D(da.zeros((50, 100, 100))).as_lazy() s.data = s.data.rechunk([50, 25, 25]) filename = tmp_path / 'test_chunking_saving_lazy.hspy' filename2 = tmp_path / 'test_chunking_saving_lazy_chunks_True.hspy' filename3 = tmp_path / 'test_chunking_saving_lazy_chunks_specified.hspy' s.save(filename) s1 = load(filename, lazy=True) assert s.data.chunks == s1.data.chunks # with chunks=True, use h5py chunking s.save(filename2, chunks=True) s2 = load(filename2, lazy=True) assert tuple([c[0] for c in s2.data.chunks]) == (7, 25, 25) # specify chunks chunks = (50, 10, 10) s.save(filename3, chunks=chunks) s3 = load(filename3, lazy=True) assert tuple([c[0] for c in s3.data.chunks]) == chunks
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 gradient(self): """ Calculate the gradient of the phase. Returns ------- gradient : Signal2D Notes ----- Appendix D in Hytch et al. Ultramicroscopy 1998 """ # Unfortunatelly, BaseSignal.map doesn't work in this case, axes_manager # set wrongly, we need to workaround axis = self.axes_manager.signal_indices_in_array self._gradient = Signal2D(gradient_phase(self.data, axis=axis)) for ax1, ax2 in zip(self._gradient.axes_manager.signal_axes, self.axes_manager.signal_axes): ax1.scale = ax2.scale ax1.offset = ax2.offset ax1.units = ax2.units return self._gradient
def test_save_load_multidim_navigation_marker(self, tmp_path, file, lazy): filename = tmp_path / file x, y = (1, 2, 3), (5, 6, 7) name = 'test point' s = Signal2D(np.arange(300).reshape(3, 10, 10)) if lazy: s = s.as_lazy() m = markers.point(x=x, y=y) 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()) 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 setup_method(self, method): rng = np.random.RandomState(123) ics = rng.laplace(size=(3, 1024)) mixing_matrix = rng.random((100, 3)) s = Signal2D((mixing_matrix @ ics).reshape((100, 32, 32))) for (axis, name) in zip(s.axes_manager._axes, ("z", "y", "x")): axis.name = name s.decomposition() mask_sig = s._get_signal_signal(dtype="bool") mask_sig.unfold() mask_sig.isig[5] = True mask_sig.fold() mask_nav = s._get_navigation_signal(dtype="bool") mask_nav.unfold() mask_nav.isig[5] = True mask_nav.fold() self.s = s self.mask_nav = mask_nav self.mask_sig = mask_sig
def setup_method(self, method): s = Signal2D(np.arange(100).reshape(10, 10)) self.s = s
def argand_diagram(self, size=[256, 256], range=None): """ Calculate and plot Argand diagram of complex signal Parameters ---------- size : [int, int], optional Size of the Argand plot in pixels (Default: [256, 256]) range : array_like, shape(2,2) or shape(2,) optional The position of the edges of the diagram (if not specified explicitly in the bins parameters): [[xmin, xmax], [ymin, ymax]]. All values outside of this range will be considered outliers and not tallied in the histogram. (Default: None) Returns ------- argand_diagram: Argand diagram as Signal2D Examples -------- >>> import hyperspy.api as hs >>> holo = hs.datasets.example_signals.object_hologram() >>> ref = hs.datasets.example_signals.reference_hologram() >>> w = holo.reconstruct_phase(ref) >>> w.argand_diagram(range=[-3, 3]).plot() """ im = self.imag.data.ravel() re = self.real.data.ravel() if range: if np.asarray(range).shape == (2,): range = [[range[0], range[1]], [range[0], range[1]]] elif np.asarray(range).shape != (2, 2): raise ValueError('display_range should be array_like, shape(2,2) or shape(2,).') argand_diagram, real_edges, imag_edges = np.histogram2d(re, im, bins=size, range=range) argand_diagram = Signal2D(argand_diagram.T) argand_diagram.metadata = self.metadata.deepcopy() argand_diagram.metadata.General.title = 'Argand diagram of {}'.format(self.metadata.General.title) if self.real.metadata.Signal.has_item('quantity'): quantity_real, units_real = parse_quantity(self.real.metadata.Signal.quantity) argand_diagram.axes_manager.signal_axes[0].name = quantity_real else: argand_diagram.axes_manager.signal_axes[0].name = 'Real' units_real = None argand_diagram.axes_manager.signal_axes[0].offset = real_edges[0] argand_diagram.axes_manager.signal_axes[0].scale = np.abs(real_edges[0] - real_edges[1]) if self.imag.metadata.Signal.has_item('quantity'): quantity_imag, units_imag = parse_quantity(self.imag.metadata.Signal.quantity) argand_diagram.axes_manager.signal_axes[1].name = quantity_imag else: argand_diagram.axes_manager.signal_axes[1].name = 'Imaginary' units_imag = None argand_diagram.axes_manager.signal_axes[1].offset = imag_edges[0] argand_diagram.axes_manager.signal_axes[1].scale = np.abs(imag_edges[0] - imag_edges[1]) if units_real: argand_diagram.axes_manager.signal_axes[0].units = units_real if units_imag: argand_diagram.axes_manager.signal_axes[1].units = units_imag return argand_diagram
def _make_heatmap_subplot(spectra): from hyperspy._signals.signal2d import Signal2D im = Signal2D(spectra.data, axes=spectra.axes_manager._get_axes_dicts()) im.metadata.General.title = spectra.metadata.General.title im.plot() return im._plot.signal_plot.ax
def setup_method(self, method): self.s = Signal2D(np.random.random((2, 3, 4, 5)))
def test_Component_fit_wrong_signal(): s = Signal2D(np.arange(2 * 3 * 4).reshape(2, 3, 4)) m = s.create_model() with pytest.raises(SignalDimensionError): ComponentFit(m, Gaussian())
def setup_method(self, method): self.im = Signal2D(np.random.random((2, 3)))