def test_write_read_nd_crystalmap_properties(self, temp_file_path, crystal_map): """Crystal map properties with more than one value in each point (e.g. top matching scores from dictionary indexing) can be written and read from file correctly. """ xmap = crystal_map map_size = xmap.size prop2d_name = "prop2d" prop2d_shape = (map_size, 2) prop2d = np.arange(map_size * 2).reshape(prop2d_shape) xmap.prop[prop2d_name] = prop2d prop3d_name = "prop3d" prop3d_shape = (map_size, 2, 2) prop3d = np.arange(map_size * 4).reshape(prop3d_shape) xmap.prop[prop3d_name] = prop3d save(filename=temp_file_path, object2write=xmap) xmap2 = load(temp_file_path) assert np.allclose(xmap2.prop[prop2d_name], xmap.prop[prop2d_name]) assert np.allclose(xmap2.prop[prop3d_name], xmap.prop[prop3d_name]) assert np.allclose(xmap2.prop[prop2d_name].reshape(prop2d_shape), prop2d) assert np.allclose(xmap2.prop[prop3d_name].reshape(prop3d_shape), prop3d)
def test_point_group_aliases(self, crystal_map, tmp_path, point_group): crystal_map.phases[0].point_group = point_group fname = tmp_path / "test_point_group_aliases.ang" save(fname, crystal_map) xmap_reload = load(fname) phase_ids = xmap_reload.phases.ids assert xmap_reload.phases[phase_ids[0]].point_group.name == point_group
def test_hdf5group2dict_update_dict(self, temp_file_path, crystal_map): save(temp_file_path, crystal_map) with File(temp_file_path, mode="r") as f: this_dict = {"hello": "there"} this_dict = hdf5group2dict(f["crystal_map"], dictionary=this_dict) assert this_dict["hello"] == "there" assert this_dict["data"] == f["crystal_map/data"] assert this_dict["header"] == f["crystal_map/header"]
def test_write_read_loop(self, crystal_map, tmp_path): fname = tmp_path / "test_write_read_loop.ang" save(filename=fname, object2write=crystal_map) xmap_reload = load(filename=fname) assert np.allclose( xmap_reload.rotations.to_euler(), crystal_map.rotations.to_euler(), ) assert np.allclose(xmap_reload.phase_id - 1, crystal_map.phase_id)
def test_points_not_in_data(self, crystal_map, tmp_path): crystal_map.prop["iq"] = np.ones(crystal_map.size) crystal_map[2].iq = 0 xmap2 = crystal_map[crystal_map.iq == 1] fname = tmp_path / "test_points_not_in_data.ang" save(fname, xmap2) xmap_reload = load(fname) assert not xmap2.is_in_data.all() assert np.allclose(xmap2.is_in_data, xmap_reload.is_indexed)
def test_overwrite_or_not_input(self, crystal_map, temp_file_path, answer, expected): save(temp_file_path, crystal_map) if answer == "m": with replace_stdin(StringIO(answer)): with pytest.raises(EOFError): _overwrite_or_not(temp_file_path) else: with replace_stdin(StringIO(answer)): assert _overwrite_or_not(temp_file_path) is expected
def test_1d_map(self, crystal_map_input, tmp_path): xmap = CrystalMap(**crystal_map_input) assert xmap.ndim == 1 fname = tmp_path / "test_1d_map.ang" save(fname, xmap) xmap_reload = load(fname) assert xmap_reload.ndim == 1 assert np.allclose(xmap.rotations.to_euler(), xmap_reload.rotations.to_euler())
def test_save_overwrite(self, temp_file_path, crystal_map, overwrite, expected_phase_name): assert crystal_map.phases[0].name == "" save(temp_file_path, crystal_map) assert os.path.isfile(temp_file_path) is True crystal_map.phases[0].name = "hepp" save(temp_file_path, crystal_map, overwrite=overwrite) crystal_map2 = load(temp_file_path) assert crystal_map2.phases[0].name == expected_phase_name
def test_write_read_masked(self, crystal_map_input, temp_file_path): cm = CrystalMap(**crystal_map_input) save(filename=temp_file_path, object2write=cm[cm.x > 2]) cm2 = load(temp_file_path) assert cm2.size != cm.size with pytest.raises(ValueError, match="operands could not be broadcast"): _ = np.allclose(cm2.x, cm.x) cm2.is_in_data = cm.is_in_data assert cm2.size == cm.size assert np.allclose(cm2.x, cm.x)
def test_non_indexed_points(self, crystal_map, tmp_path): crystal_map[2].phase_id = -1 fname = tmp_path / "test_non_indexed_points.ang" save(fname, crystal_map) xmap_reload = load(fname) crystal_map.phases[0].name = "phase1" assert xmap_reload.phases.names == crystal_map.phases.names new_phase_ids = xmap_reload.phase_id new_phase_ids[xmap_reload.is_indexed] -= 1 assert np.allclose(new_phase_ids, crystal_map.phase_id)
def test_extra_prop(self, crystal_map, tmp_path, extra_prop): fname = tmp_path / "test_extra_prop.ang" desired_arrays = [] n_points = crystal_map.size for i, name in enumerate(extra_prop): new_array = np.arange(n_points) * i crystal_map.prop[name] = new_array desired_arrays.append(new_array) save(fname, crystal_map, extra_prop=extra_prop) xmap_reload = load(fname) for name in extra_prop: assert np.allclose(xmap_reload.prop[name], crystal_map.prop[name])
def test_extra_phases(self, crystal_map, tmp_path, extra_phase_names): crystal_map.phases.add_not_indexed() for i, name in enumerate(extra_phase_names): crystal_map.phases.add(Phase(name=name)) crystal_map[i].phase_id = crystal_map.phases.id_from_name(name) fname = tmp_path / "test_extra_phases.ang" save(fname, crystal_map) xmap_reload = load(fname) crystal_map.phases[0].name = "phase1" assert np.allclose(xmap_reload.phase_id - 1, crystal_map.phase_id) pl = crystal_map.phases del pl[-1] assert xmap_reload.phases.names == pl.names
def test_read_point_group_from_v0_3_x(self, temp_file_path, crystal_map): crystal_map.phases[0].point_group = "1" save(filename=temp_file_path, object2write=crystal_map) # First, ensure point group data set name is named "symmetry", as in v0.3.0 with File(temp_file_path, mode="r+") as f: for phase in f["crystal_map/header/phases"].values(): phase["symmetry"] = phase["point_group"] del phase["point_group"] # Then, make sure it can still be read cm2 = load(filename=temp_file_path) # And that the symmetry operations are the same, for good measure print(crystal_map) print(cm2) assert np.allclose(crystal_map.phases[0].point_group.data, cm2.phases[0].point_group.data)
def test_write_data_layer_i(self, crystal_map_input, tmp_path, index): xmap = CrystalMap(**crystal_map_input) xmap.prop["ci"] = np.arange(xmap.size * xmap.rotations_per_point).reshape( (xmap.size, xmap.rotations_per_point)) xmap.prop["iq"] = np.arange(xmap.size) extra_prop = "iq_times_ci" xmap.prop[extra_prop] = xmap.ci * xmap.iq[:, np.newaxis] fname = tmp_path / "test_write_data_layer_i.ang" save(fname, xmap, index=index, extra_prop=[extra_prop, "iq"]) xmap_reload = load(fname) assert np.allclose(xmap.rotations[:, index].to_euler(), xmap_reload.rotations.to_euler()) assert np.allclose(xmap_reload.iq, np.zeros(xmap.size)) assert np.allclose(xmap_reload.ci, xmap.ci[:, index]) assert np.allclose(xmap_reload.iq_times_ci, xmap.iq_times_ci[:, index])
def dictionary_indexing(req: DictionaryIndexingIn): f = io.StringIO() logs["pattern_matching"] = f if req.ebsd_info.uid not in kp_signals: raise HTTPException(status_code=404, detail="Patterns not found") s = kp_signals[req.ebsd_info.uid] detector = kp.detectors.EBSDDetector( shape=s.axes_manager.signal_shape[::-1], pc=req.detector.pc, sample_tilt=req.detector.sample_tilt, convention=req.detector.pc_convention, tilt=req.detector.camera_tilt, ) mps = [] rotations_per_mp = [] sims_per_mp = [] for mp_req in req.masterpatterns: mp = kp.load( mp_req.filepath, projection=mp_req.projection, hemisphere="both", energy=mp_req.energy, ) mps.append(mp) rotations = sampling.get_sample_fundamental( resolution=req.angle_resolution, point_group=mp.phase.point_group.proper_subgroup, ) rotations_per_mp.append(rotations) sims = mp.get_patterns( rotations=rotations, detector=detector, energy=mp_req.energy, ) sims_per_mp.append(sims) with redirect_stderr(f): xmaps = s.match_patterns( sims_per_mp, metric=req.metric, keep_n=req.keep_n, n_slices=req.n_slices, get_orientation_similarity_map=req.osm, return_merged_crystal_map=True, ) res = DictionaryIndexingOut() if len(mps) == 1: # xmaps is a single xmap if 1 set of simulated patterns is matched against phase_name = xmaps.phases_in_data.names[0] orix_io.save(os.path.join(req.result_dir, f"xmap_{phase_name}.h5"), xmaps) xmaps.top_score = xmaps.scores[:, 0] orix_io.save( os.path.join(req.result_dir, f"xmap_{phase_name}.ang"), xmaps, confidence_index_prop="top_score", ) main_xmap = xmaps else: for xmap in xmaps[:-1]: phase_name = xmap.phases_in_data.names[0] orix_io.save(os.path.join(req.result_dir, f"xmap_{phase_name}.h5"), xmap) xmap.top_score = xmap.scores[:, 0] orix_io.save( os.path.join(req.result_dir, f"xmap_{phase_name}.ang"), xmap, confidence_index_prop="top_score", ) merged_xmap = xmaps[-1] orix_io.save(os.path.join(req.result_dir, f"xmap_merged.h5"), merged_xmap) merged_xmap.top_score = merged_xmap.scores[:, 0] orix_io.save( os.path.join(req.result_dir, f"xmap_merged.ang"), merged_xmap, confidence_index_prop="top_score", ) svg_string = io.StringIO() fig = plt.figure() ax = fig.add_subplot(projection="plot_map") ax.plot_map(merged_xmap) # ax.add_overlay(merged_xmap, merged_xmap.top_score) ax.set_yticks([]) ax.set_xticks([]) plt.savefig( svg_string, format="svg", bbox_inches="tight", transparent=True, pad_inches=0, ) svg_string.seek(0) res.phase_map = svg_string.getvalue() main_xmap = merged_xmap svg_string = io.StringIO() fig = plt.figure() ax = fig.add_subplot(projection="plot_map") im = ax.plot_map(main_xmap, main_xmap.top_score, cmap="gray") cbar = ax.add_colorbar(req.metric.upper()) ax.set_axis_off() plt.savefig(svg_string, format="svg", bbox_inches="tight", transparent=True, pad_inches=0) svg_string.seek(0) res.score_map = svg_string.getvalue() svg_string = io.StringIO() fig = plt.figure() ax = fig.add_subplot(projection="plot_map") im = ax.plot_map(main_xmap, main_xmap.osm, cmap="gray") cbar = ax.add_colorbar("Orientation Similarity") ax.set_axis_off() plt.savefig(svg_string, format="svg", bbox_inches="tight", transparent=True, pad_inches=0) svg_string.seek(0) res.os_map = svg_string.getvalue() top_euler_rotations = main_xmap.rotations.to_euler()[:, 0, :] res.rgb_orientation_map = euler_rgb_orientation_map( req.ebsd_info, top_euler_rotations) return res
def test_save_overwrite_raises(self, temp_file_path, crystal_map): with pytest.raises(ValueError, match="`overwrite` parameter can only be "): save(temp_file_path, crystal_map, overwrite=1)
def test_save_unsupported_raises(self, temp_file_path, crystal_map): _, ext = os.path.splitext(temp_file_path) with pytest.raises(IOError, match=f"'{ext}' does not correspond to any "): save(temp_file_path, crystal_map)
def test_overwrite_or_not(self, crystal_map, temp_file_path): save(temp_file_path, crystal_map) with pytest.warns(UserWarning, match="Not overwriting, since your terminal "): _overwrite_or_not(temp_file_path)
from orix import sampling, io import kikuchipy as kp s_large = kp.data.nickel_ebsd_large() s_large.remove_static_background() s_large.remove_dynamic_background() s_large.average_neighbour_patterns(window="gaussian", std=2) mp = kp.data.nickel_ebsd_master_pattern_small(projection="lambert") r = sampling.get_sample_fundamental( resolution=4, space_group=mp.phase.space_group.number ) detector = kp.detectors.EBSDDetector( shape=s_large.axes_manager.signal_shape[::-1], pc=[0.421, 0.7794, 0.5049], convention="tsl", sample_tilt=70, ) sim = mp.get_patterns(rotations=r, detector=detector, energy=20, compute=False) xmap = s_large.dictionary_indexing(sim, keep_n=1, metric="ncc") io.save("/home/hakon/ni_large.h5", xmap)
def test_file_reader(self, crystal_map, temp_file_path): save(filename=temp_file_path, object2write=crystal_map) cm2 = load(filename=temp_file_path) assert_dictionaries_are_equal(crystal_map.__dict__, cm2.__dict__)
def test_file_writer_raises(self, temp_file_path, crystal_map): with pytest.raises(OSError, match="Cannot write to the already open file "): with File(temp_file_path, mode="w") as _: save(temp_file_path, crystal_map, overwrite=True)
def test_file_writer(self, crystal_map, temp_file_path): save(filename=temp_file_path, object2write=crystal_map) with File(temp_file_path, mode="r") as f: assert f["manufacturer"][()][0].decode() == "orix" assert f["version"][()][0].decode() == orix_version
def test_3d_map_raises(self, crystal_map_input, tmp_path): xmap = CrystalMap(**crystal_map_input) fname = tmp_path / "test_3d_raises.ang" with pytest.raises(ValueError, match="Writing a 3D dataset to an .ang file"): save(fname, xmap)