Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DiamondLightSource_python-murfey /tests /util /test_fib_util.py
| import xml.etree.ElementTree as ET | |
| from pathlib import Path | |
| from unittest.mock import MagicMock | |
| import pytest | |
| from pytest_mock import MockerFixture | |
| from murfey.util.fib import number_from_name, parse_image_metadata | |
| from murfey.util.models import FIBImageMetadata | |
| from tests.conftest import ExampleVisit | |
| session_id = 10 | |
| visit_name = f"{ExampleVisit.proposal_code}{ExampleVisit.proposal_number}-{ExampleVisit.visit_number}" | |
| instrument_name = ExampleVisit.instrument_name | |
| def visit_dir(tmp_path: Path): | |
| visit_dir = tmp_path / "data/2020" / visit_name | |
| visit_dir.mkdir(parents=True, exist_ok=True) | |
| return visit_dir | |
| def create_image_metadata( | |
| voltage: float, | |
| shift_x: float, | |
| shift_y: float, | |
| len_x: float, | |
| len_y: float, | |
| pos_x: float, | |
| pos_y: float, | |
| pos_z: float, | |
| rotation: float, | |
| tilt_alpha: float, | |
| tilt_beta: float, | |
| pixels_x: int, | |
| pixels_y: int, | |
| pixel_size_x: float, | |
| pixel_size_y: float, | |
| ): | |
| # Create the XML Element structure present in the file | |
| root = ET.Element("Metadata") | |
| # ------ | |
| # Optics | |
| # ------ | |
| optics_node = ET.Element("Optics") | |
| voltage_node = ET.Element("AccelerationVoltage") | |
| voltage_node.text = str(voltage) | |
| optics_node.append(voltage_node) | |
| beam_shift_node = ET.Element("BeamShift") | |
| shift_x_node = ET.Element("X") | |
| shift_x_node.text = str(shift_x) | |
| beam_shift_node.append(shift_x_node) | |
| shift_y_node = ET.Element("Y") | |
| shift_y_node.text = str(shift_y) | |
| beam_shift_node.append(shift_y_node) | |
| optics_node.append(beam_shift_node) | |
| fov_node = ET.Element("ScanFieldOfView") | |
| len_x_node = ET.Element("X") | |
| len_x_node.text = str(len_x) | |
| fov_node.append(len_x_node) | |
| len_y_node = ET.Element("Y") | |
| len_y_node.text = str(len_y) | |
| fov_node.append(len_y_node) | |
| optics_node.append(fov_node) | |
| root.append(optics_node) | |
| # ------------- | |
| # StageSettings | |
| # ------------- | |
| stage_settings_node = ET.Element("StageSettings") | |
| # x, y, z | |
| stage_node = ET.Element("StagePosition") | |
| pos_x_node = ET.Element("X") | |
| pos_x_node.text = str(pos_x) | |
| stage_node.append(pos_x_node) | |
| pos_y_node = ET.Element("Y") | |
| pos_y_node.text = str(pos_y) | |
| stage_node.append(pos_y_node) | |
| pos_z_node = ET.Element("Z") | |
| pos_z_node.text = str(pos_z) | |
| stage_node.append(pos_z_node) | |
| rotation_node = ET.Element("Rotation") | |
| rotation_node.text = str(rotation) | |
| stage_node.append(rotation_node) | |
| # Angles | |
| tilt_node = ET.Element("Tilt") | |
| tilt_alpha_node = ET.Element("Alpha") | |
| tilt_alpha_node.text = str(tilt_alpha) | |
| tilt_node.append(tilt_alpha_node) | |
| tilt_beta_node = ET.Element("Beta") | |
| tilt_beta_node.text = str(tilt_beta) | |
| tilt_node.append(tilt_beta_node) | |
| stage_node.append(tilt_node) | |
| stage_settings_node.append(stage_node) | |
| root.append(stage_settings_node) | |
| # ------------ | |
| # BinaryResult | |
| # ------------ | |
| binary_result_node = ET.Element("BinaryResult") | |
| # ImageSize | |
| image_size_node = ET.Element("ImageSize") | |
| pixels_x_node = ET.Element("X") | |
| pixels_x_node.text = str(pixels_x) | |
| image_size_node.append(pixels_x_node) | |
| pixels_y_node = ET.Element("Y") | |
| pixels_y_node.text = str(pixels_y) | |
| image_size_node.append(pixels_y_node) | |
| binary_result_node.append(image_size_node) | |
| # PixelSize | |
| pixel_size_node = ET.Element("PixelSize") | |
| pixel_size_x_node = ET.Element("X") | |
| pixel_size_x_node.text = str(pixel_size_x) | |
| pixel_size_node.append(pixel_size_x_node) | |
| pixel_size_y_node = ET.Element("Y") | |
| pixel_size_y_node.text = str(pixel_size_y) | |
| pixel_size_node.append(pixel_size_y_node) | |
| binary_result_node.append(pixel_size_node) | |
| root.append(binary_result_node) | |
| xml_string = ET.tostring(root, encoding="unicode", xml_declaration=True) | |
| return xml_string | |
| def test_parse_metadata( | |
| mocker: MockerFixture, | |
| test_params: tuple[ | |
| str, | |
| str, | |
| str, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| float, | |
| int, | |
| int, | |
| int, | |
| float, | |
| float, | |
| ], | |
| visit_dir: Path, | |
| ): | |
| # Unpack test params | |
| ( | |
| tag_key, | |
| image_name, | |
| project_name, | |
| voltage, | |
| shift_x, | |
| shift_y, | |
| len_x, | |
| len_y, | |
| pos_x, | |
| pos_y, | |
| pos_z, | |
| rotation, | |
| rotation_offset, | |
| tilt_alpha, | |
| tilt_beta, | |
| expected_slot_number, | |
| pixels_x, | |
| pixels_y, | |
| pixel_size_x, | |
| pixel_size_y, | |
| ) = test_params | |
| file = ( | |
| visit_dir | |
| / "autotem" | |
| / project_name | |
| / "Sites" | |
| / "Lamella" | |
| / "LamellaEvaluationImages" | |
| / image_name | |
| ) | |
| # Mock the results of opening an image file | |
| xml_string = create_image_metadata( | |
| voltage, | |
| shift_x, | |
| shift_y, | |
| len_x, | |
| len_y, | |
| pos_x, | |
| pos_y, | |
| pos_z, | |
| rotation, | |
| tilt_alpha, | |
| tilt_beta, | |
| pixels_x, | |
| pixels_y, | |
| pixel_size_x, | |
| pixel_size_y, | |
| ) | |
| tags = dict.fromkeys(["Metadata", "MetadataAsINI"], 0) | |
| tags[tag_key] = xml_string | |
| mock_image = MagicMock(text=tags) | |
| mocker.patch( | |
| "murfey.util.fib.PIL.Image.open", | |
| return_value=mock_image, | |
| ) | |
| # Run the function and check that output is correct | |
| parsed = FIBImageMetadata( | |
| visit_name=visit_name, | |
| file=file, | |
| **parse_image_metadata(file, rotation_offset), | |
| ) | |
| assert parsed.visit_name == visit_name | |
| assert parsed.file == file | |
| assert parsed.voltage == voltage | |
| assert parsed.shift_x == shift_x | |
| assert parsed.shift_y == shift_y | |
| assert parsed.len_x == len_x | |
| assert parsed.len_y == len_y | |
| assert parsed.pos_x == pos_x | |
| assert parsed.pos_y == pos_y | |
| assert parsed.pos_z == pos_z | |
| assert parsed.rotation == rotation | |
| assert parsed.tilt_alpha == tilt_alpha | |
| assert parsed.tilt_beta == tilt_beta | |
| assert parsed.pixels_x == pixels_x | |
| assert parsed.pixels_y == pixels_y | |
| assert parsed.pixel_size_x == pixel_size_x | |
| assert parsed.pixel_size_y == pixel_size_y | |
| assert parsed.slot_number == expected_slot_number | |
| assert parsed.site_name == f"{project_name}--slot_{expected_slot_number}" | |
| assert parsed.pixel_size == 0.5 * (pixel_size_x + pixel_size_y) | |
| def test_number_from_name(test_params: tuple[str, int]): | |
| name, number = test_params | |
| assert number_from_name(name) == number | |
Xet Storage Details
- Size:
- 8.49 kB
- Xet hash:
- b46cb9be26c95981bf4b02a07c4d1dad25b3f4006e31eb59085d6b0bacac9cd5
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.