From 82007da6c10676a912fa8077efc2269b45e05efb Mon Sep 17 00:00:00 2001
From: Simon Wittl <simon.wittl@th-deg.de>
Date: Thu, 12 Dec 2024 07:21:44 +0100
Subject: [PATCH] Thd io
---
example/convert_projections.py | 25 ++
example/projection_example.py | 10 +-
example/tigre_example.py | 42 +--
example/volume_example.py | 17 +-
rq_controller/common/__init__.py | 4 +-
rq_controller/common/io/loader.py | 24 +-
rq_controller/common/io/rq_json/__init__.py | 4 +-
rq_controller/common/io/rq_json/json_load.py | 90 ++++--
rq_controller/common/io/rq_json/json_write.py | 101 ++++--
rq_controller/common/io/thd/__init__.py | 5 +
rq_controller/common/io/thd/thd_load.py | 125 +++++++
rq_controller/common/io/thd/thd_write.py | 86 +++++
rq_controller/common/io/writer.py | 107 +++---
rq_controller/common/projection.py | 304 ++++++++++++------
rq_controller/common/projection_geometry.py | 116 +++++--
rq_controller/common/region_of_intrest.py | 80 ++---
rq_controller/common/volume.py | 91 +++---
rq_controller/rq_workflow.py | 61 ++--
rq_controller/tf2/static_broadcaster.py | 42 +--
setup.py | 29 +-
...st_base_loader.cpython-38-pytest-8.2.2.pyc | Bin 2839 -> 2839 bytes
...st_base_writer.cpython-38-pytest-8.2.2.pyc | Bin 10618 -> 10630 bytes
...est_projection.cpython-38-pytest-8.2.2.pyc | Bin 20692 -> 19665 bytes
...ction_geometry.cpython-38-pytest-8.2.2.pyc | Bin 11871 -> 11883 bytes
...ion_of_intrest.cpython-38-pytest-8.2.2.pyc | Bin 12566 -> 12566 bytes
.../test_volume.cpython-38-pytest-8.2.2.pyc | Bin 9180 -> 9180 bytes
test/test_base_loader.py | 10 +-
test/test_base_writer.py | 55 +++-
test/test_projection.py | 73 ++++-
test/test_projection_geometry.py | 54 ++--
test/test_region_of_intrest.py | 31 +-
test/test_volume.py | 24 +-
32 files changed, 1118 insertions(+), 492 deletions(-)
create mode 100644 example/convert_projections.py
create mode 100644 rq_controller/common/io/thd/__init__.py
create mode 100644 rq_controller/common/io/thd/thd_load.py
create mode 100644 rq_controller/common/io/thd/thd_write.py
diff --git a/example/convert_projections.py b/example/convert_projections.py
new file mode 100644
index 0000000..b5f5051
--- /dev/null
+++ b/example/convert_projections.py
@@ -0,0 +1,25 @@
+from rq_controller.common.io.rq_json import RqJsonWriter
+from rq_controller.common.io.thd import RawLoader
+from pathlib import Path
+
+
+FOLDER = Path(r"C:\Users\swittl\Downloads\defect_detection\defect_detection\object_2")
+SAVE_FOLDER = Path(
+ r"C:\Users\swittl\Downloads\defect_detection\defect_detection\rq_converted\object_2"
+)
+
+
+def main():
+ writer = RqJsonWriter()
+ loader = RawLoader()
+
+ projections_files = FOLDER.glob("*.raw")
+
+ for i, file in enumerate(projections_files):
+ projection = loader.load_projection(file)
+ save_path = writer.get_next_projection_save_path(SAVE_FOLDER)
+ writer.write_projection(save_path, projection, optional=True)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/example/projection_example.py b/example/projection_example.py
index 4b6fd05..23df07d 100644
--- a/example/projection_example.py
+++ b/example/projection_example.py
@@ -3,7 +3,8 @@ from rq_controller.common.io.rq_json import RqJsonWriter, RqJsonLoader
from pathlib import Path
-FOLDER = Path('./example/data')
+FOLDER = Path("./example/data")
+
def main():
projection_2 = PyProjection.dummy()
@@ -13,12 +14,13 @@ def main():
loader = RqJsonLoader()
writer.write_projection(writer.get_projection_save_path_i(FOLDER, 2), projection_2)
-
+
projection_1 = loader.load_projection(writer.get_projection_save_path_i(FOLDER, 1))
print(projection_1)
projection_2 = loader.load_projection(writer.get_projection_save_path_i(FOLDER, 2))
print(projection_2)
-if __name__ == '__main__':
- main()
\ No newline at end of file
+
+if __name__ == "__main__":
+ main()
diff --git a/example/tigre_example.py b/example/tigre_example.py
index fd7c551..be4aaeb 100644
--- a/example/tigre_example.py
+++ b/example/tigre_example.py
@@ -5,7 +5,6 @@ import rclpy
from scipy.spatial.transform import Rotation
import numpy as np
-import matplotlib.pyplot as plt
# !!!
@@ -13,8 +12,9 @@ import matplotlib.pyplot as plt
# !!!
NUMBER_OF_PROJECTION = 80
-FOD_MM = 1000.
-FDD_MM = 2000.
+FOD_MM = 1000.0
+FDD_MM = 2000.0
+
def main():
# Initialize workflow node
@@ -24,10 +24,10 @@ def main():
projection_stack: list[PyProjection] = list()
projection = PyProjection.dummy()
projection.image = np.zeros((1000, 1000), dtype=np.uint16)
- projection.voltage_kv = 200.
- projection.current_ua = 10.
- projection.detector_heigth_mm = 200.
- projection.detector_width_mm = 200.
+ projection.voltage_kv = 200.0
+ projection.current_ua = 10.0
+ projection.detector_heigth_mm = 200.0
+ projection.detector_width_mm = 200.0
# create the source and detector positions
source = np.array([FOD_MM, 0, 0])
@@ -36,21 +36,25 @@ def main():
# Move source / dtector and aquire projections
for i in range(NUMBER_OF_PROJECTION):
- rotation = Rotation.from_euler('Z', angles[i], False)
- scan_pose = projection.look_at(rotation.apply(source) + (np.random.random(3) - 0.5) * 30,
- rotation.apply(detector) + (np.random.random(3) - 0.5) * 30,
- np.array([0, 0, -1]))
+ rotation = Rotation.from_euler("Z", angles[i], False)
+ scan_pose = projection.look_at(
+ rotation.apply(source) + (np.random.random(3) - 0.5) * 30,
+ rotation.apply(detector) + (np.random.random(3) - 0.5) * 30,
+ np.array([0, 0, -1]),
+ )
projection_stack.append(workflow.aquire_projection(scan_pose))
# Define reconstruction area and call reconstruction client
- roi = PyRegionOfIntrest(center_points_mm=np.array([0., 0., 0.]),
- dimensions_mm=np.array([120., 120., 120.]),
- resolution_mm=np.array([0.5, 0.5, 0.5]))
+ roi = PyRegionOfIntrest(
+ center_points_mm=np.array([0.0, 0.0, 0.0]),
+ dimensions_mm=np.array([120.0, 120.0, 120.0]),
+ resolution_mm=np.array([0.5, 0.5, 0.5]),
+ )
+
+ workflow.reconstruction.set_reconstruction_algorithm_name("ossart") # ossart / fdk
+ workflow.get_volume(projection_stack, roi)
- workflow.reconstruction.set_reconstruction_algorithm_name('ossart') # ossart / fdk
- volume = workflow.get_volume(projection_stack, roi)
-
-if __name__ == '__main__':
+if __name__ == "__main__":
rclpy.init()
- main()
\ No newline at end of file
+ main()
diff --git a/example/volume_example.py b/example/volume_example.py
index b462199..68d515c 100644
--- a/example/volume_example.py
+++ b/example/volume_example.py
@@ -4,34 +4,33 @@ from pathlib import Path
import numpy as np
-FOLDER = Path('./example/data')
+FOLDER = Path("./example/data")
def main():
volume = PyVolume.dummy()
- print(f'Shape (x / y / z): {volume.shape}')
+ print(f"Shape (x / y / z): {volume.shape}")
msg = volume.as_message()
- print(f'Number of slices: {len(msg.slices)}')
+ print(f"Number of slices: {len(msg.slices)}")
volume_2 = PyVolume.from_message(msg)
- print(f'Shape (x / y / z): {volume_2.shape}')
+ print(f"Shape (x / y / z): {volume_2.shape}")
writer = RqJsonWriter()
writer.write_volume(writer.get_volume_save_path_i(FOLDER, 1), volume_2)
loader = RqJsonLoader()
volume_3 = loader.load_volume(writer.get_volume_save_path_i(FOLDER, 1))
- print(f'Shape (x / y / z): {volume_3.shape}')
+ print(f"Shape (x / y / z): {volume_3.shape}")
grid = volume_3.roi.get_grid()
- print(f'grid shape: {grid.shape}')
+ print(f"grid shape: {grid.shape}")
- pos = volume_3.roi.next_neighbor(grid, np.array([0., 0., 0.]))
+ pos = volume_3.roi.next_neighbor(grid, np.array([0.0, 0.0, 0.0]))
print(pos)
value = volume_3.array[pos[0], pos[1], pos[2]]
print(value)
-if __name__ == '__main__':
+if __name__ == "__main__":
main()
-
diff --git a/rq_controller/common/__init__.py b/rq_controller/common/__init__.py
index 49190b8..c0676a1 100644
--- a/rq_controller/common/__init__.py
+++ b/rq_controller/common/__init__.py
@@ -1,2 +1,4 @@
from .projection import PyProjectionGeometry, PyProjection
-from .volume import PyVolume, PyRegionOfIntrest
\ No newline at end of file
+from .volume import PyVolume, PyRegionOfIntrest
+
+__all__ = ["PyProjectionGeometry", "PyProjection", "PyVolume", "PyRegionOfIntrest"]
diff --git a/rq_controller/common/io/loader.py b/rq_controller/common/io/loader.py
index 4ce8e32..66c7b5c 100644
--- a/rq_controller/common/io/loader.py
+++ b/rq_controller/common/io/loader.py
@@ -1,16 +1,15 @@
-import numpy as np
-import json
from pathlib import Path
from ...common import PyProjectionGeometry, PyProjection, PyRegionOfIntrest, PyVolume
-class BaseDataLoader():
- def __init__(self,
- porjection_geometry_suffix: str,
- projection_suffix: str,
- region_of_intrest_suffix: str,
- volume_suffix: str):
-
+class BaseDataLoader:
+ def __init__(
+ self,
+ porjection_geometry_suffix: str,
+ projection_suffix: str,
+ region_of_intrest_suffix: str,
+ volume_suffix: str,
+ ):
self.porjection_geometry_suffix = porjection_geometry_suffix
self.projection_suffix = projection_suffix
self.region_of_intrest_suffix = region_of_intrest_suffix
@@ -18,13 +17,12 @@ class BaseDataLoader():
def load_projection_geometry(self, load_path: Path) -> PyProjectionGeometry:
raise NotImplementedError()
-
+
def load_projection(self, load_path: Path) -> PyProjection:
raise NotImplementedError()
-
+
def load_region_of_intrest(self, load_path: Path) -> PyRegionOfIntrest:
raise NotImplementedError()
-
+
def load_volume(self, load_path: Path) -> PyVolume:
raise NotImplementedError()
-
\ No newline at end of file
diff --git a/rq_controller/common/io/rq_json/__init__.py b/rq_controller/common/io/rq_json/__init__.py
index f6f5812..4d08736 100644
--- a/rq_controller/common/io/rq_json/__init__.py
+++ b/rq_controller/common/io/rq_json/__init__.py
@@ -1,2 +1,4 @@
from .json_load import RqJsonLoader
-from .json_write import RqJsonWriter
\ No newline at end of file
+from .json_write import RqJsonWriter
+
+__all__ = ["RqJsonLoader", "RqJsonWriter"]
diff --git a/rq_controller/common/io/rq_json/json_load.py b/rq_controller/common/io/rq_json/json_load.py
index 2a9d6e6..0bd1a5d 100644
--- a/rq_controller/common/io/rq_json/json_load.py
+++ b/rq_controller/common/io/rq_json/json_load.py
@@ -1,18 +1,24 @@
import numpy as np
-import json
+import json
from pathlib import Path
-from ..loader import BaseDataLoader, PyProjection, PyProjectionGeometry, PyRegionOfIntrest, PyVolume
+from ..loader import (
+ BaseDataLoader,
+ PyProjection,
+ PyProjectionGeometry,
+ PyRegionOfIntrest,
+ PyVolume,
+)
from PIL import Image
import pyometiff
class RqJsonLoader(BaseDataLoader):
def __init__(self):
- super().__init__('.geom-json', '.tif', '.roi-json', '.ome.tiff')
+ super().__init__(".geom-json", ".tif", ".roi-json", ".ome.tiff")
def load_json(self, load_path: Path) -> dict:
- with open(str(load_path), 'r') as f:
+ with open(str(load_path), "r") as f:
data_dict = json.load(f)
return data_dict
@@ -20,57 +26,71 @@ class RqJsonLoader(BaseDataLoader):
data_dict = self.load_json(load_path)
projection_geometry = PyProjectionGeometry(
- focal_spot_mm=np.array([data_dict['focal_spot_mm']]),
- detector_postion_mm=np.array([data_dict['detector_postion_mm']]),
- detector_orientation_quad=np.array([data_dict['detector_orientation_quad']]),
- frame_id=data_dict['frame_id'],
- focal_spot_orientation_quad=np.array(data_dict['focal_spot_orientation_quad']))
-
+ focal_spot_mm=np.array([data_dict["focal_spot_mm"]]),
+ detector_postion_mm=np.array([data_dict["detector_postion_mm"]]),
+ detector_orientation_quad=np.array(
+ [data_dict["detector_orientation_quad"]]
+ ),
+ frame_id=data_dict["frame_id"],
+ focal_spot_orientation_quad=np.array(
+ data_dict["focal_spot_orientation_quad"]
+ ),
+ )
+
return projection_geometry
-
+
def load_projection(self, load_path: Path) -> PyProjection:
- load_path_projection_geometry = load_path.parent / f'{load_path.stem}{self.porjection_geometry_suffix}'
+ load_path_projection_geometry = (
+ load_path.parent / f"{load_path.stem}{self.porjection_geometry_suffix}"
+ )
data_dict = self.load_json(load_path_projection_geometry)
image = np.asarray(Image.open(load_path))
projection = PyProjection(
- focal_spot_mm=np.array([data_dict['focal_spot_mm']]),
- detector_postion_mm=np.array([data_dict['detector_postion_mm']]),
- detector_orientation_quad=np.array([data_dict['detector_orientation_quad']]),
+ focal_spot_mm=np.array([data_dict["focal_spot_mm"]]),
+ detector_postion_mm=np.array([data_dict["detector_postion_mm"]]),
+ detector_orientation_quad=np.array(
+ [data_dict["detector_orientation_quad"]]
+ ),
image=image,
- detector_heigth_mm=data_dict['detector_heigth_mm'],
- detector_width_mm=data_dict['detector_width_mm'],
- frame_id=data_dict['frame_id'],
- focal_spot_orientation_quad=np.array(data_dict['focal_spot_orientation_quad']),
- voltage_kv=data_dict['voltage_kv'],
- current_ua=data_dict['current_ua'],
- exposure_time_ms=data_dict['exposure_time_ms'])
-
+ detector_heigth_mm=data_dict["detector_heigth_mm"],
+ detector_width_mm=data_dict["detector_width_mm"],
+ frame_id=data_dict["frame_id"],
+ focal_spot_orientation_quad=np.array(
+ data_dict["focal_spot_orientation_quad"]
+ ),
+ voltage_kv=data_dict["voltage_kv"],
+ current_ua=data_dict["current_ua"],
+ exposure_time_ms=data_dict["exposure_time_ms"],
+ )
+
return projection
-
+
def load_region_of_intrest(self, load_path: Path) -> PyRegionOfIntrest:
data_dict = self.load_json(load_path)
region_of_intrest = PyRegionOfIntrest(
- center_points_mm=np.array(data_dict['center_points_mm']),
- dimensions_mm=np.array(data_dict['dimensions_mm']),
- frame_id=data_dict['frame_id'],
- resolution_mm=np.array(data_dict['resolution_mm']))
-
+ center_points_mm=np.array(data_dict["center_points_mm"]),
+ dimensions_mm=np.array(data_dict["dimensions_mm"]),
+ frame_id=data_dict["frame_id"],
+ resolution_mm=np.array(data_dict["resolution_mm"]),
+ )
+
return region_of_intrest
-
+
def load_volume(self, load_path: Path) -> PyVolume:
- load_path_roi = load_path.parent / f'{load_path.stem}{self.region_of_intrest_suffix}'
+ load_path_roi = (
+ load_path.parent / f"{load_path.stem}{self.region_of_intrest_suffix}"
+ )
roi = self.load_region_of_intrest(load_path_roi)
reader = pyometiff.OMETIFFReader(load_path)
volume, _, _ = reader.read()
-
+
if volume.dtype == np.uint16:
data_type = 0
elif volume.dtype == np.uint8:
data_type = 1
else:
- raise ValueError('data type not implemented.')
-
- return PyVolume(volume, roi, data_type)
+ raise ValueError("data type not implemented.")
+ return PyVolume(volume, roi, data_type)
diff --git a/rq_controller/common/io/rq_json/json_write.py b/rq_controller/common/io/rq_json/json_write.py
index e5d6de8..0d14c0d 100644
--- a/rq_controller/common/io/rq_json/json_write.py
+++ b/rq_controller/common/io/rq_json/json_write.py
@@ -1,73 +1,104 @@
-import numpy as np
-import json
+import json
from pathlib import Path
-from ..writer import BaseDataWriter, PyProjection, PyProjectionGeometry, PyRegionOfIntrest, PyVolume
+from ..writer import (
+ BaseDataWriter,
+ PyProjection,
+ PyProjectionGeometry,
+ PyRegionOfIntrest,
+ PyVolume,
+)
from PIL import Image
import pyometiff
class RqJsonWriter(BaseDataWriter):
def __init__(self):
- super().__init__('.geom-json', '.tif', '.roi-json', '.ome.tiff')
+ super().__init__(".geom-json", ".tif", ".roi-json", ".ome.tiff")
def write_json(self, save_path: Path, data_dict: dict):
- with open(str(save_path), 'w') as f:
+ with open(str(save_path), "w") as f:
json.dump(data_dict, f, indent=2)
- def write_projection_geometry(self, save_path: Path, projection_geometry: PyProjectionGeometry):
+ def write_projection_geometry(
+ self, save_path: Path, projection_geometry: PyProjectionGeometry
+ ):
data_dict = dict()
- #geometry
- data_dict['focal_spot_mm'] = projection_geometry.focal_spot_mm.tolist()
- data_dict['detector_postion_mm'] = projection_geometry.detector_postion_mm.tolist()
- data_dict['detector_orientation_quad'] = projection_geometry.detector_orientation_quad.tolist()
- data_dict['focal_spot_orientation_quad'] = projection_geometry.focal_spot_orientation_quad.tolist()
-
- data_dict['frame_id'] = projection_geometry.frame_id
+ # geometry
+ data_dict["focal_spot_mm"] = projection_geometry.focal_spot_mm.tolist()
+ data_dict["detector_postion_mm"] = (
+ projection_geometry.detector_postion_mm.tolist()
+ )
+ data_dict["detector_orientation_quad"] = (
+ projection_geometry.detector_orientation_quad.tolist()
+ )
+ data_dict["focal_spot_orientation_quad"] = (
+ projection_geometry.focal_spot_orientation_quad.tolist()
+ )
+
+ data_dict["frame_id"] = projection_geometry.frame_id
self.write_json(save_path, data_dict)
- def write_projection(self, save_path: Path, projection: PyProjection):
- save_path_projection_geometry = save_path.parent / f'{save_path.stem}{self.porjection_geometry_suffix}'
+ def write_projection(
+ self, save_path: Path, projection: PyProjection, optional: bool = False
+ ):
+ save_path_projection_geometry = (
+ save_path.parent / f"{save_path.stem}{self.porjection_geometry_suffix}"
+ )
data_dict = dict()
# geometry
- data_dict['focal_spot_mm'] = projection.focal_spot_mm.tolist()
- data_dict['detector_postion_mm'] = projection.detector_postion_mm.tolist()
- data_dict['detector_orientation_quad'] = projection.detector_orientation_quad.tolist()
- data_dict['focal_spot_orientation_quad'] = projection.focal_spot_orientation_quad.tolist()
-
+ data_dict["focal_spot_mm"] = projection.focal_spot_mm.tolist()
+ data_dict["detector_postion_mm"] = projection.detector_postion_mm.tolist()
+ data_dict["detector_orientation_quad"] = (
+ projection.detector_orientation_quad.tolist()
+ )
+ data_dict["focal_spot_orientation_quad"] = (
+ projection.focal_spot_orientation_quad.tolist()
+ )
+
# detector
- data_dict['pixel_pitch_x_mm'] = projection.pixel_pitch_x_mm
- data_dict['pixel_pitch_y_mm'] = projection.pixel_pitch_y_mm
- data_dict['detector_heigth_mm'] = projection.detector_heigth_mm
- data_dict['detector_width_mm'] = projection.detector_width_mm
+ data_dict["pixel_pitch_x_mm"] = projection.pixel_pitch_x_mm
+ data_dict["pixel_pitch_y_mm"] = projection.pixel_pitch_y_mm
+ data_dict["detector_heigth_mm"] = projection.detector_heigth_mm
+ data_dict["detector_width_mm"] = projection.detector_width_mm
# xray
- data_dict['exposure_time_ms'] = projection.exposure_time_ms
- data_dict['voltage_kv'] = projection.voltage_kv
- data_dict['current_ua'] = projection.current_ua
- data_dict['frame_id'] = projection.frame_id
+ data_dict["exposure_time_ms"] = projection.exposure_time_ms
+ data_dict["voltage_kv"] = projection.voltage_kv
+ data_dict["current_ua"] = projection.current_ua
+ data_dict["frame_id"] = projection.frame_id
+
+ # extra / converted information
+ if optional:
+ data_dict["optional"] = dict(
+ projection_matrix_cera=projection.projection_matrix_cera_px.tolist()
+ )
self.write_json(save_path_projection_geometry, data_dict)
image = Image.fromarray(projection.image)
image.save(save_path)
- def write_region_of_intrest(self, save_path: Path, region_of_intrest: PyRegionOfIntrest):
+ def write_region_of_intrest(
+ self, save_path: Path, region_of_intrest: PyRegionOfIntrest
+ ):
data_dict = dict()
# geometry
- data_dict['center_points_mm'] = region_of_intrest.center_points_mm.tolist()
- data_dict['dimensions_mm'] = region_of_intrest.dimensions_mm.tolist()
- data_dict['frame_id'] = region_of_intrest.frame_id
- data_dict['resolution_mm'] = region_of_intrest.resolution_mm.tolist()
+ data_dict["center_points_mm"] = region_of_intrest.center_points_mm.tolist()
+ data_dict["dimensions_mm"] = region_of_intrest.dimensions_mm.tolist()
+ data_dict["frame_id"] = region_of_intrest.frame_id
+ data_dict["resolution_mm"] = region_of_intrest.resolution_mm.tolist()
self.write_json(save_path, data_dict)
def write_volume(self, save_path: Path, volume: PyVolume):
- save_path_region_of_intrest = save_path.parent / f'{save_path.stem}{self.region_of_intrest_suffix}'
+ save_path_region_of_intrest = (
+ save_path.parent / f"{save_path.stem}{self.region_of_intrest_suffix}"
+ )
self.write_region_of_intrest(save_path_region_of_intrest, volume.roi)
writer = pyometiff.OMETIFFWriter(save_path, volume.array, dict())
- writer.write()
\ No newline at end of file
+ writer.write()
diff --git a/rq_controller/common/io/thd/__init__.py b/rq_controller/common/io/thd/__init__.py
new file mode 100644
index 0000000..84f08e8
--- /dev/null
+++ b/rq_controller/common/io/thd/__init__.py
@@ -0,0 +1,5 @@
+from .thd_load import RawLoader
+from .thd_write import RawWriter
+
+
+__all__ = ["RawLoader", "RawWriter"]
diff --git a/rq_controller/common/io/thd/thd_load.py b/rq_controller/common/io/thd/thd_load.py
new file mode 100644
index 0000000..257d6cb
--- /dev/null
+++ b/rq_controller/common/io/thd/thd_load.py
@@ -0,0 +1,125 @@
+import numpy as np
+import json
+from pathlib import Path
+
+try:
+ from PythonTools.raw2py import raw2py
+ from PythonTools.ezrt_header import EzrtHeader
+ from PythonTools.rek2py import rek2py
+except ModuleNotFoundError:
+ raise ModuleNotFoundError("Install PythonTools from Fraunhofer EZRT.")
+
+from ..loader import (
+ BaseDataLoader,
+ PyProjection,
+ PyProjectionGeometry,
+ PyRegionOfIntrest,
+ PyVolume,
+)
+from scipy.spatial.transform import Rotation
+
+from ..rq_json.json_load import RqJsonLoader
+
+
+class RawLoader(BaseDataLoader):
+ def __init__(self):
+ super().__init__(".raw", ".raw", ".roi-json", ".rek")
+
+ def load_projection_geometry(self, load_path: Path) -> PyProjectionGeometry:
+ header = EzrtHeader.fromfile(load_path)
+
+ focal_spot_mm = np.array(header.agv_source_position) * 1000.0
+ detector_postion_mm = np.array(header.agv_detector_center_position) * 1000.0
+
+ line = np.array(header.agv_detector_line_direction)
+ column = np.array(header.agv_detector_col_direction)
+ normal = np.cross(line, column)
+
+ matrix = np.eye(3)
+ matrix[:, 0] = line
+ matrix[:, 1] = column
+ matrix[:, 2] = normal
+
+ rotation = Rotation.from_matrix(matrix)
+ detector_orientation_quad = rotation.as_quat()
+
+ frame_id = header.number_of_images
+
+ projection_geometry = PyProjectionGeometry(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ frame_id,
+ focal_spot_orientation_quad=np.array([0.0, 0.0, 0.0, 1.0]),
+ )
+
+ return projection_geometry
+
+ def load_projection(
+ self, load_path: Path, switch_order: bool = True
+ ) -> PyProjection:
+ header, image = raw2py(load_path, switch_order=switch_order)
+
+ focal_spot_mm = np.array(header.agv_source_position) * 1000.0
+ detector_postion_mm = np.array(header.agv_detector_center_position) * 1000.0
+
+ line = np.array(header.agv_detector_line_direction)
+ column = np.array(header.agv_detector_col_direction)
+ normal = np.cross(line, column)
+
+ matrix = np.eye(3)
+ matrix[:, 0] = line
+ matrix[:, 1] = column
+ matrix[:, 2] = normal
+
+ rotation = Rotation.from_matrix(matrix)
+ detector_orientation_quad = rotation.as_quat()
+
+ frame_id = header.number_of_images
+
+ detector_heigth_mm = header.pixel_width_in_um / 1000.0 * image.shape[1]
+ detector_width_mm = header.pixel_width_in_um / 1000.0 * image.shape[0]
+
+ voltage_kv = header.voltage_in_kv
+ current_ua = header.current_in_ua
+ exposure_time_ms = header.exposure_time_in_ms
+
+ projection = PyProjection(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ image,
+ detector_heigth_mm,
+ detector_width_mm,
+ frame_id,
+ np.array([0.0, 0.0, 0.0, 1.0]),
+ voltage_kv,
+ current_ua,
+ exposure_time_ms,
+ )
+
+ return projection
+
+ def load_json(self, load_path: Path) -> dict:
+ with open(str(load_path), "r") as f:
+ data_dict = json.load(f)
+ return data_dict
+
+ def load_region_of_intrest(self, load_path: Path) -> PyRegionOfIntrest:
+ RqJsonLoader.load_region_of_intrest(self, load_path)
+
+ def load_volume(self, load_path: Path) -> PyVolume:
+ header, volume = rek2py(load_path)
+ load_path_roi = (
+ load_path.parent / f"{load_path.stem}{self.region_of_intrest_suffix}"
+ )
+ roi = self.load_region_of_intrest(load_path_roi)
+
+ if volume.dtype == np.uint16:
+ data_type = 0
+ elif volume.dtype == np.uint8:
+ data_type = 1
+ else:
+ raise ValueError("data type not implemented.")
+
+ return PyVolume(volume, roi, data_type)
diff --git a/rq_controller/common/io/thd/thd_write.py b/rq_controller/common/io/thd/thd_write.py
new file mode 100644
index 0000000..ee0f3bf
--- /dev/null
+++ b/rq_controller/common/io/thd/thd_write.py
@@ -0,0 +1,86 @@
+from pathlib import Path
+
+from ..writer import (
+ BaseDataWriter,
+ PyProjection,
+ PyProjectionGeometry,
+ PyRegionOfIntrest,
+ PyVolume,
+)
+
+try:
+ from PythonTools.py2raw import py2raw
+ from PythonTools.ezrt_header import EzrtHeader
+ from PythonTools.py2rek import py2rek
+except ModuleNotFoundError:
+ raise ModuleNotFoundError("Install PythonTools from Fraunhofer EZRT.")
+
+
+from ..rq_json.json_write import RqJsonWriter
+
+
+class RawWriter(BaseDataWriter):
+ def __init__(self):
+ super().__init__(".raw", ".raw", ".roi-json", ".rek")
+
+ def write_projection_geometry(
+ self, save_path: Path, projection_geometry: PyProjectionGeometry
+ ):
+ header = EzrtHeader()
+ header.agv_source_position = (
+ projection_geometry.focal_spot_mm / 1000.0
+ ).tolist()
+ header.agv_detector_center_position = (
+ projection_geometry.detector_postion_mm / 1000.0
+ ).tolist()
+
+ line = projection_geometry.detector_rotation_matrix[:, 0]
+ column = projection_geometry.detector_rotation_matrix[:, 0]
+
+ header.agv_detector_line_direction = line
+ header.agv_detector_col_direction = column
+
+ header.number_of_images = projection_geometry.frame_id
+ header.tofile(save_path)
+
+ def write_projection(
+ self, save_path: Path, projection: PyProjection, swith_order: bool = False
+ ):
+ projection_geometry = projection.get_projection_geometry()
+
+ header = EzrtHeader()
+
+ header.agv_source_position = (
+ projection_geometry.focal_spot_mm / 1000.0
+ ).tolist()
+ header.agv_detector_center_position = (
+ projection_geometry.detector_postion_mm / 1000.0
+ ).tolist()
+
+ line = projection_geometry.detector_rotation_matrix[:, 0]
+ column = projection_geometry.detector_rotation_matrix[:, 0]
+
+ header.agv_detector_line_direction = line
+ header.agv_detector_col_direction = column
+
+ header.number_of_images = projection_geometry.frame_id
+ header.pixel_width_in_um = projection.pixel_pitch_x_mm * 1000.0
+ header.voltage_in_kv = projection.voltage_kv
+ header.current_in_ua = projection.current_ua
+ header.exposure_time_in_ms = projection.exposure_time_ms
+
+ py2raw(projection.image, save_path, header, swith_order)
+
+ def write_region_of_intrest(
+ self, save_path: Path, region_of_intrest: PyRegionOfIntrest
+ ):
+ RqJsonWriter.write_region_of_intrest(self, save_path, region_of_intrest)
+
+ def write_volume(self, save_path: Path, volume: PyVolume):
+ header = EzrtHeader()
+ header.num_voxel_x = volume.shape[0]
+ header.num_voxel_y = volume.shape[1]
+ header.num_voxel_z = volume.shape[2]
+ header.pixel_width_in_um = volume.roi.resolution_mm[0]
+
+ py2rek(volume.array, save_path, header, True)
diff --git a/rq_controller/common/io/writer.py b/rq_controller/common/io/writer.py
index f9475c3..91ae744 100644
--- a/rq_controller/common/io/writer.py
+++ b/rq_controller/common/io/writer.py
@@ -1,70 +1,101 @@
-import numpy as np
-import json
from pathlib import Path
from ...common import PyProjectionGeometry, PyProjection, PyRegionOfIntrest, PyVolume
-class BaseDataWriter():
- projection_name: str = 'projection'
- projection_geometry_name: str ='geometry'
- region_of_intrest_name: str = 'roi'
- volume_name: str = 'volume'
+class BaseDataWriter:
+ projection_name: str = "projection"
+ projection_geometry_name: str = "geometry"
+ region_of_intrest_name: str = "roi"
+ volume_name: str = "volume"
- def __init__(self,
- porjection_geometry_suffix: str,
- projection_suffix: str,
- region_of_intrest_suffix: str,
- volume_suffix: str):
-
+ def __init__(
+ self,
+ porjection_geometry_suffix: str,
+ projection_suffix: str,
+ region_of_intrest_suffix: str,
+ volume_suffix: str,
+ ):
self.porjection_geometry_suffix = porjection_geometry_suffix
self.projection_suffix = projection_suffix
self.region_of_intrest_suffix = region_of_intrest_suffix
self.volume_suffix = volume_suffix
- def write_projection_geometry(self, save_path: Path, projection_geometry: PyProjectionGeometry):
+ def write_projection_geometry(
+ self, save_path: Path, projection_geometry: PyProjectionGeometry
+ ):
raise NotImplementedError()
-
+
def write_projection(self, save_path: Path, projection: PyProjection):
raise NotImplementedError()
-
- def write_region_of_intrest(self, save_path: Path, region_of_intrest: PyRegionOfIntrest):
+
+ def write_region_of_intrest(
+ self, save_path: Path, region_of_intrest: PyRegionOfIntrest
+ ):
raise NotImplementedError
-
+
def write_volume(self, save_path: Path, volume: PyVolume):
raise NotImplementedError()
-
+
def get_next_projection_save_path(self, save_folder: Path) -> Path:
- return self.get_projection_save_path_i(save_folder, self.number_of_projections(save_folder) + 1)
+ return self.get_projection_save_path_i(
+ save_folder, self.number_of_projections(save_folder) + 1
+ )
def get_projection_save_path_i(self, save_folder: Path, i) -> Path:
- return save_folder / f'{self.projection_name}_{i:05}{self.projection_suffix}'
-
+ return save_folder / f"{self.projection_name}_{i:05}{self.projection_suffix}"
+
def get_next_projection_geometry_save_path(self, save_folder: Path) -> Path:
- return self.get_projection_geometry_save_path_i(save_folder, self.number_of_projection_geometries(save_folder) + 1)
+ return self.get_projection_geometry_save_path_i(
+ save_folder, self.number_of_projection_geometries(save_folder) + 1
+ )
def get_projection_geometry_save_path_i(self, save_folder: Path, i) -> Path:
- return save_folder / f'{self.projection_geometry_name}_{i:05}{self.porjection_geometry_suffix}'
-
+ return (
+ save_folder
+ / f"{self.projection_geometry_name}_{i:05}{self.porjection_geometry_suffix}"
+ )
+
def get_next_region_of_intrest_save_path(self, save_folder: Path) -> Path:
- return self.get_region_of_intrest_save_path_i(save_folder, self.number_of_region_of_intrests(save_folder) + 1)
+ return self.get_region_of_intrest_save_path_i(
+ save_folder, self.number_of_region_of_intrests(save_folder) + 1
+ )
def get_region_of_intrest_save_path_i(self, save_folder: Path, i) -> Path:
- return save_folder / f'{self.region_of_intrest_name}_{i:05}{self.region_of_intrest_suffix}'
-
+ return (
+ save_folder
+ / f"{self.region_of_intrest_name}_{i:05}{self.region_of_intrest_suffix}"
+ )
+
def get_next_volume_save_path(self, save_folder: Path) -> Path:
- return self.get_volume_save_path_i(save_folder, self.number_of_volumes(save_folder) + 1)
+ return self.get_volume_save_path_i(
+ save_folder, self.number_of_volumes(save_folder) + 1
+ )
def get_volume_save_path_i(self, save_folder: Path, i) -> Path:
- return save_folder / f'{self.volume_name}_{i:05}{self.volume_suffix}'
-
+ return save_folder / f"{self.volume_name}_{i:05}{self.volume_suffix}"
+
def number_of_projection_geometries(self, folder: Path) -> int:
- return len(list(folder.glob(f'{self.projection_geometry_name}*{self.porjection_geometry_suffix}')))
-
+ return len(
+ list(
+ folder.glob(
+ f"{self.projection_geometry_name}*{self.porjection_geometry_suffix}"
+ )
+ )
+ )
+
def number_of_projections(self, folder: Path) -> int:
- return len(list(folder.glob(f'{self.projection_name}*{self.projection_suffix}')))
-
+ return len(
+ list(folder.glob(f"{self.projection_name}*{self.projection_suffix}"))
+ )
+
def number_of_region_of_intrests(self, folder: Path) -> int:
- return len(list(folder.glob(f'{self.region_of_intrest_name}*{self.region_of_intrest_suffix}')))
-
+ return len(
+ list(
+ folder.glob(
+ f"{self.region_of_intrest_name}*{self.region_of_intrest_suffix}"
+ )
+ )
+ )
+
def number_of_volumes(self, folder: Path) -> int:
- return len(list(folder.glob(f'{self.volume_name}*{self.volume_suffix}')))
+ return len(list(folder.glob(f"{self.volume_name}*{self.volume_suffix}")))
diff --git a/rq_controller/common/projection.py b/rq_controller/common/projection.py
index d69ab60..2f81509 100644
--- a/rq_controller/common/projection.py
+++ b/rq_controller/common/projection.py
@@ -24,10 +24,20 @@ class PyProjection(PyProjectionGeometry):
exposure_time_ms (float): The exposure time in milliseconds.
"""
- def __init__(self, focal_spot_mm: ndarray, detector_postion_mm: ndarray, detector_orientation_quad: ndarray, image: np.ndarray,
- detector_heigth_mm: float, detector_width_mm: float, frame_id: str = 'object',
- focal_spot_orientation_quad: np.ndarray = np.array([0., 0., 0, 1.]),
- voltage_kv: float = 100., current_ua: float = 100., exposure_time_ms: float = 1000.) -> None:
+ def __init__(
+ self,
+ focal_spot_mm: ndarray,
+ detector_postion_mm: ndarray,
+ detector_orientation_quad: ndarray,
+ image: np.ndarray,
+ detector_heigth_mm: float,
+ detector_width_mm: float,
+ frame_id: str = "object",
+ focal_spot_orientation_quad: np.ndarray = np.array([0.0, 0.0, 0, 1.0]),
+ voltage_kv: float = 100.0,
+ current_ua: float = 100.0,
+ exposure_time_ms: float = 1000.0,
+ ) -> None:
"""
Initializes a PyProjection instance.
@@ -44,8 +54,14 @@ class PyProjection(PyProjectionGeometry):
current_ua (float): The current in microamperes. Default is 100.
exposure_time_ms (float): The exposure time in milliseconds. Default is 1000.
"""
-
- super().__init__(focal_spot_mm, detector_postion_mm, detector_orientation_quad, frame_id, focal_spot_orientation_quad)
+
+ super().__init__(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ frame_id,
+ focal_spot_orientation_quad,
+ )
self.image = image.astype(np.uint16)
self.detector_heigth_mm = detector_heigth_mm
self.detector_width_mm = detector_width_mm
@@ -62,19 +78,31 @@ class PyProjection(PyProjectionGeometry):
PyProjection: A dummy instance with default values.
"""
- return cls(np.array([0., 100., 0]),
- np.array([0., -100., 0]),
- np.array([1., 0., 0, 1.]),
- np.random.randint(0, 65535, size=(10, 10), dtype=np.uint16),
- 10., 10.)
-
+ return cls(
+ np.array([0.0, 100.0, 0]),
+ np.array([0.0, -100.0, 0]),
+ np.array([1.0, 0.0, 0, 1.0]),
+ np.random.randint(0, 65535, size=(10, 10), dtype=np.uint16),
+ 10.0,
+ 10.0,
+ )
+
@classmethod
- def from_look_at(cls, focal_spot_mm: ndarray, detector_postion_mm: ndarray, image_shape: tuple[int],
- detector_heigth_mm: float, detector_width_mm: float, frame_id: str = 'object',
- voltage_kv: float = 100., current_ua: float = 100., exposure_time_ms: float = 1000.,
- up_vector: np.ndarray = np.array([0., 0., 1.])) -> 'PyProjection':
+ def from_look_at(
+ cls,
+ focal_spot_mm: ndarray,
+ detector_postion_mm: ndarray,
+ image_shape: tuple[int],
+ detector_heigth_mm: float,
+ detector_width_mm: float,
+ frame_id: str = "object",
+ voltage_kv: float = 100.0,
+ current_ua: float = 100.0,
+ exposure_time_ms: float = 1000.0,
+ up_vector: np.ndarray = np.array([0.0, 0.0, 1.0]),
+ ) -> "PyProjection":
image = np.zeros(image_shape, np.uint16)
-
+
vector = focal_spot_mm - detector_postion_mm
vector = vector / np.linalg.norm(vector)
up_vector = up_vector / np.linalg.norm(up_vector)
@@ -82,47 +110,78 @@ class PyProjection(PyProjectionGeometry):
detector_orientation = np.eye(3)
detector_orientation[:, 2] = vector
detector_orientation[:, 1] = np.cross(up_vector, vector)
- detector_orientation[:, 0] = np.cross(detector_orientation[:, 1], detector_orientation[:, 2])
+ detector_orientation[:, 0] = np.cross(
+ detector_orientation[:, 1], detector_orientation[:, 2]
+ )
source_orientation = np.eye(3)
source_orientation[:, 2] = -vector
source_orientation[:, 1] = np.cross(up_vector, -vector)
- source_orientation[:, 0] = np.cross(source_orientation[:, 1], source_orientation[:, 2])
+ source_orientation[:, 0] = np.cross(
+ source_orientation[:, 1], source_orientation[:, 2]
+ )
return cls(
- focal_spot_mm, detector_postion_mm,
+ focal_spot_mm,
+ detector_postion_mm,
Rotation.from_matrix(detector_orientation).as_quat(),
- image, detector_heigth_mm, detector_width_mm,
- frame_id, Rotation.from_matrix(source_orientation).as_quat(),
- voltage_kv, current_ua, exposure_time_ms)
-
- def look_at(self, focal_spot_mm: ndarray, detector_postion_mm: ndarray, up_vector: np.ndarray = np.array([0., 0., 1.])) -> PyProjection:
+ image,
+ detector_heigth_mm,
+ detector_width_mm,
+ frame_id,
+ Rotation.from_matrix(source_orientation).as_quat(),
+ voltage_kv,
+ current_ua,
+ exposure_time_ms,
+ )
+
+ def look_at(
+ self,
+ focal_spot_mm: ndarray,
+ detector_postion_mm: ndarray,
+ up_vector: np.ndarray = np.array([0.0, 0.0, 1.0]),
+ ) -> PyProjection:
vector = focal_spot_mm - detector_postion_mm
vector = vector / np.linalg.norm(vector)
up_vector = up_vector / np.linalg.norm(up_vector)
- z_rot = Rotation.from_euler('Z', -90, True)
+ z_rot = Rotation.from_euler("Z", -90, True)
detector_orientation = np.eye(3)
detector_orientation[:, 2] = vector
detector_orientation[:, 1] = np.cross(up_vector, vector)
- detector_orientation[:, 0] = np.cross(detector_orientation[:, 1], detector_orientation[:, 2])
+ detector_orientation[:, 0] = np.cross(
+ detector_orientation[:, 1], detector_orientation[:, 2]
+ )
- detector_orientation_quad = (Rotation.from_matrix(detector_orientation) * z_rot).as_quat()
+ detector_orientation_quad = (
+ Rotation.from_matrix(detector_orientation) * z_rot
+ ).as_quat()
source_orientation = np.eye(3)
source_orientation[:, 2] = -vector
source_orientation[:, 1] = np.cross(up_vector, -vector)
- source_orientation[:, 0] = np.cross(source_orientation[:, 1], source_orientation[:, 2])
- source_orientation_quad = (Rotation.from_matrix(source_orientation) * z_rot).as_quat()
-
+ source_orientation[:, 0] = np.cross(
+ source_orientation[:, 1], source_orientation[:, 2]
+ )
+ source_orientation_quad = (
+ Rotation.from_matrix(source_orientation) * z_rot
+ ).as_quat()
+
return PyProjection(
- focal_spot_mm, detector_postion_mm, detector_orientation_quad, self.image,
- self.detector_heigth_mm, self.detector_width_mm,
- self.frame_id, source_orientation_quad, self.voltage_kv,
- self.current_ua, self.exposure_time_ms)
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ self.image,
+ self.detector_heigth_mm,
+ self.detector_width_mm,
+ self.frame_id,
+ source_orientation_quad,
+ self.voltage_kv,
+ self.current_ua,
+ self.exposure_time_ms,
+ )
-
def __str__(self) -> str:
"""
Returns a string representation of the PyProjection instance.
@@ -130,14 +189,18 @@ class PyProjection(PyProjectionGeometry):
Returns:
str: The string representation of the projection.
"""
- print_str = f'---\n'
- print_str += f'PyProjection\n'
- print_str += f'--- Projection Geometry:\n'
- print_str += f'Detector Posiion [mm]: \t {self.detector_postion_mm.tolist()} \n'
- print_str += f'Focal Spot [mm]: \t {self.focal_spot_mm.tolist()} \n'
- print_str += f'Detector Orientation [quad]: \t {self.detector_orientation_quad.tolist()} \n'
- print_str += f'Focal Spot Orientation [quad]: \t {self.focal_spot_orientation_quad.tolist()} \n'
- print_str += f'---\n\n'
+ print_str = "---\n"
+ print_str += "PyProjection\n"
+ print_str += "--- Projection Geometry:\n"
+ print_str += (
+ f"Detector Posiion [mm]: \t {self.detector_postion_mm.tolist()} \n"
+ )
+ print_str += (
+ f"Focal Spot [mm]: \t {self.focal_spot_mm.tolist()} \n"
+ )
+ print_str += f"Detector Orientation [quad]: \t {self.detector_orientation_quad.tolist()} \n"
+ print_str += f"Focal Spot Orientation [quad]: \t {self.focal_spot_orientation_quad.tolist()} \n"
+ print_str += "---\n\n"
return print_str
@classmethod
@@ -151,25 +214,40 @@ class PyProjection(PyProjectionGeometry):
Returns:
PyProjection: An instance initialized from the ROS message.
"""
- focal_spot_mm = np.array([msg.projection_geometry.focal_spot_postion_mm.x,
- msg.projection_geometry.focal_spot_postion_mm.y,
- msg.projection_geometry.focal_spot_postion_mm.z,])
-
- detector_center_mm = np.array([msg.projection_geometry.detector_postion_mm.x,
- msg.projection_geometry.detector_postion_mm.y,
- msg.projection_geometry.detector_postion_mm.z,])
-
- detector_orientation_quad = np.array([msg.projection_geometry.detector_orientation_quad.x,
- msg.projection_geometry.detector_orientation_quad.y,
- msg.projection_geometry.detector_orientation_quad.z,
- msg.projection_geometry.detector_orientation_quad.w])
-
- focal_spot_orientation = np.array([msg.projection_geometry.focal_spot_orientation_quad.x,
- msg.projection_geometry.focal_spot_orientation_quad.y,
- msg.projection_geometry.focal_spot_orientation_quad.z,
- msg.projection_geometry.focal_spot_orientation_quad.w])
-
-
+ focal_spot_mm = np.array(
+ [
+ msg.projection_geometry.focal_spot_postion_mm.x,
+ msg.projection_geometry.focal_spot_postion_mm.y,
+ msg.projection_geometry.focal_spot_postion_mm.z,
+ ]
+ )
+
+ detector_center_mm = np.array(
+ [
+ msg.projection_geometry.detector_postion_mm.x,
+ msg.projection_geometry.detector_postion_mm.y,
+ msg.projection_geometry.detector_postion_mm.z,
+ ]
+ )
+
+ detector_orientation_quad = np.array(
+ [
+ msg.projection_geometry.detector_orientation_quad.x,
+ msg.projection_geometry.detector_orientation_quad.y,
+ msg.projection_geometry.detector_orientation_quad.z,
+ msg.projection_geometry.detector_orientation_quad.w,
+ ]
+ )
+
+ focal_spot_orientation = np.array(
+ [
+ msg.projection_geometry.focal_spot_orientation_quad.x,
+ msg.projection_geometry.focal_spot_orientation_quad.y,
+ msg.projection_geometry.focal_spot_orientation_quad.z,
+ msg.projection_geometry.focal_spot_orientation_quad.w,
+ ]
+ )
+
detector_heigth_mm = msg.detector_heigth_mm
detector_width_mm = msg.detector_width_mm
frame_id = msg.projection_geometry.header.frame_id
@@ -180,10 +258,20 @@ class PyProjection(PyProjectionGeometry):
current_ua = msg.current_ua
exposure_time_ms = msg.exposure_time_ms
- return cls(focal_spot_mm, detector_center_mm, detector_orientation_quad, image,
- detector_heigth_mm, detector_width_mm, frame_id, focal_spot_orientation,
- voltage_kv, current_ua, exposure_time_ms)
-
+ return cls(
+ focal_spot_mm,
+ detector_center_mm,
+ detector_orientation_quad,
+ image,
+ detector_heigth_mm,
+ detector_width_mm,
+ frame_id,
+ focal_spot_orientation,
+ voltage_kv,
+ current_ua,
+ exposure_time_ms,
+ )
+
def as_message(self) -> Projection:
"""
Converts the PyProjection instance to a ROS message.
@@ -197,7 +285,9 @@ class PyProjection(PyProjectionGeometry):
self.focal_spot_mm = self.focal_spot_mm.reshape((3,))
self.detector_postion_mm = self.detector_postion_mm.reshape((3,))
self.detector_orientation_quad = self.detector_orientation_quad.reshape((4,))
- self.focal_spot_orientation_quad = self.focal_spot_orientation_quad.reshape((4,))
+ self.focal_spot_orientation_quad = self.focal_spot_orientation_quad.reshape(
+ (4,)
+ )
projection_geometry.focal_spot_postion_mm.x = float(self.focal_spot_mm[0])
projection_geometry.focal_spot_postion_mm.y = float(self.focal_spot_mm[1])
@@ -207,18 +297,34 @@ class PyProjection(PyProjectionGeometry):
projection_geometry.detector_postion_mm.y = float(self.detector_postion_mm[1])
projection_geometry.detector_postion_mm.z = float(self.detector_postion_mm[2])
- projection_geometry.detector_orientation_quad.x = float(self.detector_orientation_quad[0])
- projection_geometry.detector_orientation_quad.y = float(self.detector_orientation_quad[1])
- projection_geometry.detector_orientation_quad.z = float(self.detector_orientation_quad[2])
- projection_geometry.detector_orientation_quad.w = float(self.detector_orientation_quad[3])
-
- projection_geometry.focal_spot_orientation_quad.x = float(self.focal_spot_orientation_quad[0])
- projection_geometry.focal_spot_orientation_quad.y = float(self.focal_spot_orientation_quad[1])
- projection_geometry.focal_spot_orientation_quad.z = float(self.focal_spot_orientation_quad[2])
- projection_geometry.focal_spot_orientation_quad.w = float(self.focal_spot_orientation_quad[3])
+ projection_geometry.detector_orientation_quad.x = float(
+ self.detector_orientation_quad[0]
+ )
+ projection_geometry.detector_orientation_quad.y = float(
+ self.detector_orientation_quad[1]
+ )
+ projection_geometry.detector_orientation_quad.z = float(
+ self.detector_orientation_quad[2]
+ )
+ projection_geometry.detector_orientation_quad.w = float(
+ self.detector_orientation_quad[3]
+ )
+
+ projection_geometry.focal_spot_orientation_quad.x = float(
+ self.focal_spot_orientation_quad[0]
+ )
+ projection_geometry.focal_spot_orientation_quad.y = float(
+ self.focal_spot_orientation_quad[1]
+ )
+ projection_geometry.focal_spot_orientation_quad.z = float(
+ self.focal_spot_orientation_quad[2]
+ )
+ projection_geometry.focal_spot_orientation_quad.w = float(
+ self.focal_spot_orientation_quad[3]
+ )
message.projection_geometry = projection_geometry
- message.image = ros2_numpy.msgify(Image, self.image, 'mono16')
+ message.image = ros2_numpy.msgify(Image, self.image, "mono16")
message.detector_heigth_mm = self.detector_heigth_mm
message.detector_width_mm = self.detector_width_mm
@@ -230,28 +336,46 @@ class PyProjection(PyProjectionGeometry):
message.exposure_time_ms = self.exposure_time_ms
return message
-
+
def get_projection_geometry(self) -> PyProjectionGeometry:
- return PyProjectionGeometry(self.focal_spot_mm,
- self.detector_postion_mm,
- self.detector_orientation_quad,
- self.frame_id,
- self.focal_spot_orientation_quad)
-
+ return PyProjectionGeometry(
+ self.focal_spot_mm,
+ self.detector_postion_mm,
+ self.detector_orientation_quad,
+ self.frame_id,
+ self.focal_spot_orientation_quad,
+ )
+
@property
def detector_heigth_px(self) -> int:
return self.image.shape[0]
-
+
@property
def detector_width_px(self) -> int:
return self.image.shape[1]
-
+
@property
def pixel_pitch_x_mm(self) -> float:
return self.detector_width_mm / self.detector_width_px
-
+
@property
def pixel_pitch_y_mm(self) -> float:
return self.detector_heigth_mm / self.detector_heigth_px
-
-
+
+ @property
+ def to_cera_transformation_matrix(self) -> np.ndarray:
+ transformation_matrix = np.eye(3)
+ # [mm] -> [px]
+ transformation_matrix[2, 2] = 1.0 / self.pixel_pitch_x_mm
+ transformation_matrix[0, 2] = -self.detector_width_px / 2.0
+ transformation_matrix[1, 2] = -self.detector_heigth_px / 2.0
+
+ return transformation_matrix
+
+ @property
+ def projection_matrix_cera_px(self):
+ projection_geometry = self.get_projection_geometry()
+ return (
+ np.linalg.inv(self.to_cera_transformation_matrix)
+ @ projection_geometry.projection_matrix
+ )
diff --git a/rq_controller/common/projection_geometry.py b/rq_controller/common/projection_geometry.py
index 61bc500..2c94ff6 100644
--- a/rq_controller/common/projection_geometry.py
+++ b/rq_controller/common/projection_geometry.py
@@ -2,9 +2,11 @@ from __future__ import annotations
import numpy as np
-from rq_interfaces.msg import ProjectionGeometry, Projection
+from rq_interfaces.msg import ProjectionGeometry
+from scipy.spatial.transform import Rotation
-class PyProjectionGeometry():
+
+class PyProjectionGeometry:
"""
Represents the geometry of a projection including the focal spot and detector position and orientation.
@@ -16,10 +18,14 @@ class PyProjectionGeometry():
frame_id (str): Frame ID for the projection geometry.
"""
- def __init__(self, focal_spot_mm: np.ndarray, detector_postion_mm: np.ndarray,
- detector_orientation_quad: np.ndarray,
- frame_id: str = 'object', focal_spot_orientation_quad: np.ndarray = np.array([0., 0., 0, 1.])
- ) -> None:
+ def __init__(
+ self,
+ focal_spot_mm: np.ndarray,
+ detector_postion_mm: np.ndarray,
+ detector_orientation_quad: np.ndarray,
+ frame_id: str = "object",
+ focal_spot_orientation_quad: np.ndarray = np.array([0.0, 0.0, 0, 1.0]),
+ ) -> None:
"""
Initializes a PyProjectionGeometry instance.
@@ -45,9 +51,11 @@ class PyProjectionGeometry():
Returns:
PyProjectionGeometry: A dummy instance with default values.
"""
- return cls(np.array([1., 0., 0]),
- np.array([-1., 0., 0]),
- np.array([0., 0., 0, 1.]))
+ return cls(
+ np.array([1.0, 0.0, 0]),
+ np.array([-1.0, 0.0, 0]),
+ np.array([0.0, 0.0, 0, 1.0]),
+ )
@classmethod
def from_message(cls, msg: ProjectionGeometry):
@@ -60,28 +68,50 @@ class PyProjectionGeometry():
Returns:
PyProjectionGeometry: An instance initialized from the ROS message.
"""
- focal_spot_mm = np.array([msg.focal_spot_postion_mm.x,
- msg.focal_spot_postion_mm.y,
- msg.focal_spot_postion_mm.z,])
-
- detector_center_mm = np.array([msg.detector_postion_mm.x,
- msg.detector_postion_mm.y,
- msg.detector_postion_mm.z,])
-
- detector_orientation_quad = np.array([msg.detector_orientation_quad.x,
- msg.detector_orientation_quad.y,
- msg.detector_orientation_quad.z,
- msg.detector_orientation_quad.w])
-
- focal_spot_orientation = np.array([msg.focal_spot_orientation_quad.x,
- msg.focal_spot_orientation_quad.y,
- msg.focal_spot_orientation_quad.z,
- msg.focal_spot_orientation_quad.w])
-
+ focal_spot_mm = np.array(
+ [
+ msg.focal_spot_postion_mm.x,
+ msg.focal_spot_postion_mm.y,
+ msg.focal_spot_postion_mm.z,
+ ]
+ )
+
+ detector_center_mm = np.array(
+ [
+ msg.detector_postion_mm.x,
+ msg.detector_postion_mm.y,
+ msg.detector_postion_mm.z,
+ ]
+ )
+
+ detector_orientation_quad = np.array(
+ [
+ msg.detector_orientation_quad.x,
+ msg.detector_orientation_quad.y,
+ msg.detector_orientation_quad.z,
+ msg.detector_orientation_quad.w,
+ ]
+ )
+
+ focal_spot_orientation = np.array(
+ [
+ msg.focal_spot_orientation_quad.x,
+ msg.focal_spot_orientation_quad.y,
+ msg.focal_spot_orientation_quad.z,
+ msg.focal_spot_orientation_quad.w,
+ ]
+ )
+
frame_id = msg.header.frame_id
- return cls(focal_spot_mm, detector_center_mm, detector_orientation_quad, frame_id, focal_spot_orientation)
-
+ return cls(
+ focal_spot_mm,
+ detector_center_mm,
+ detector_orientation_quad,
+ frame_id,
+ focal_spot_orientation,
+ )
+
def as_message(self) -> ProjectionGeometry:
"""
Converts the PyProjectionGeometry instance to a ROS message.
@@ -111,4 +141,30 @@ class PyProjectionGeometry():
message.header.frame_id = self.frame_id
- return message
\ No newline at end of file
+ return message
+
+ @property
+ def detector_rotation_matrix(self) -> np.ndarray:
+ return Rotation.from_quat(self.detector_orientation_quad).as_matrix()
+
+ @property
+ def detector_horizontal_vector(self) -> np.ndarray:
+ return self.detector_rotation_matrix[:, 0]
+
+ @property
+ def detector_vertical_vector(self) -> np.ndarray:
+ return self.detector_rotation_matrix[:, 1]
+
+ @property
+ def projection_matrix(self) -> np.ndarray:
+ p3x3 = np.vstack(
+ [
+ self.detector_horizontal_vector,
+ self.detector_vertical_vector,
+ self.detector_postion_mm - self.focal_spot_mm,
+ ]
+ ).T
+ p3x3_inv = np.linalg.inv(p3x3)
+ p4 = (p3x3_inv @ (-self.focal_spot_mm)).reshape((3, 1))
+ matrix = np.concatenate([p3x3_inv, p4], 1).reshape((3, 4))
+ return matrix
diff --git a/rq_controller/common/region_of_intrest.py b/rq_controller/common/region_of_intrest.py
index 4a71fda..e7cbe2f 100644
--- a/rq_controller/common/region_of_intrest.py
+++ b/rq_controller/common/region_of_intrest.py
@@ -6,7 +6,7 @@ from rq_interfaces.msg import RegionOfIntrest
from visualization_msgs.msg import Marker
-class PyRegionOfIntrest():
+class PyRegionOfIntrest:
"""
Represents a region of interest (ROI) with center points, dimensions, and resolution.
@@ -17,8 +17,13 @@ class PyRegionOfIntrest():
resolution_mm (np.ndarray): Resolution of the ROIs in millimeters.
"""
- def __init__(self, center_points_mm: np.ndarray, dimensions_mm: np.ndarray, frame_id: str = 'object',
- resolution_mm: np.ndarray = np.array([0.1, 0.1, 0.1])):
+ def __init__(
+ self,
+ center_points_mm: np.ndarray,
+ dimensions_mm: np.ndarray,
+ frame_id: str = "object",
+ resolution_mm: np.ndarray = np.array([0.1, 0.1, 0.1]),
+ ):
"""
Initializes a PyRegionOfIntrest instance.
@@ -43,8 +48,7 @@ class PyRegionOfIntrest():
PyRegionOfIntrest: A dummy instance with random values.
"""
- return cls((np.random.random((3, )) - 0.5) * 20.,
- np.random.random((3, )) * 10.)
+ return cls((np.random.random((3,)) - 0.5) * 20.0, np.random.random((3,)) * 10.0)
@classmethod
def from_message(cls, msg: RegionOfIntrest):
@@ -64,22 +68,20 @@ class PyRegionOfIntrest():
for roi in msg.region_of_intrest_stack.markers:
roi: Marker
center_points_mm.append(
- np.array([roi.pose.position.x,
- roi.pose.position.y,
- roi.pose.position.z]))
-
- dimensions_mm.append(
- np.array([roi.scale.x,
- roi.scale.y,
- roi.scale.z]))
-
+ np.array(
+ [roi.pose.position.x, roi.pose.position.y, roi.pose.position.z]
+ )
+ )
+
+ dimensions_mm.append(np.array([roi.scale.x, roi.scale.y, roi.scale.z]))
+
frame = roi.header.frame_id
- resolution_mm = np.array([msg.resolution.x,
- msg.resolution.y,
- msg.resolution.z])
-
- return cls(np.array(center_points_mm), np.array(dimensions_mm), frame, resolution_mm)
-
+ resolution_mm = np.array([msg.resolution.x, msg.resolution.y, msg.resolution.z])
+
+ return cls(
+ np.array(center_points_mm), np.array(dimensions_mm), frame, resolution_mm
+ )
+
@property
def number_of_rois(self) -> int:
"""
@@ -90,7 +92,7 @@ class PyRegionOfIntrest():
"""
return self.center_points_mm.shape[0]
-
+
@property
def shape(self) -> tuple:
"""
@@ -102,7 +104,7 @@ class PyRegionOfIntrest():
shape = self.dimensions_mm[0] // self.resolution_mm[0]
return (int(shape[0]), int(shape[1]), int(shape[2]))
-
+
def as_message(self) -> RegionOfIntrest:
"""
Converts the PyRegionOfIntrest instance to a ROS message.
@@ -127,8 +129,8 @@ class PyRegionOfIntrest():
roi.header.frame_id = self.frame_id
- roi_list.append(roi)
-
+ roi_list.append(roi)
+
message.region_of_intrest_stack.markers = roi_list
message.resolution.x = float(self.resolution_mm[0][0])
@@ -136,7 +138,7 @@ class PyRegionOfIntrest():
message.resolution.z = float(self.resolution_mm[0][2])
return message
-
+
def get_grid(self, indice: int = 0) -> np.ndarray:
"""
Generates a grid of points within the ROI.
@@ -148,21 +150,19 @@ class PyRegionOfIntrest():
np.ndarray: A grid of points within the ROI.
"""
- start = self.center_points_mm[indice] - (self.dimensions_mm[indice] / 2.)
- end = self.center_points_mm[indice] + (self.dimensions_mm[indice] / 2.)
-
+ start = self.center_points_mm[indice] - (self.dimensions_mm[indice] / 2.0)
+ end = self.center_points_mm[indice] + (self.dimensions_mm[indice] / 2.0)
+
x_ = np.linspace(start[0], end[0], self.shape[0])
y_ = np.linspace(start[1], end[1], self.shape[1])
z_ = np.linspace(start[2], end[2], self.shape[2])
- x, y, z = np.meshgrid(x_, y_, z_, indexing='ij')
+ x, y, z = np.meshgrid(x_, y_, z_, indexing="ij")
+
+ return np.concatenate(
+ (np.expand_dims(x, -1), np.expand_dims(y, -1), np.expand_dims(z, -1)), -1
+ )
- return np.concatenate((
- np.expand_dims(x, -1),
- np.expand_dims(y, -1),
- np.expand_dims(z, -1)),
- -1)
-
@staticmethod
def next_neighbor(grid_mm: np.ndarray, point_mm: np.ndarray) -> np.ndarray:
"""
@@ -175,13 +175,13 @@ class PyRegionOfIntrest():
Returns:
np.ndarray: The indices of the nearest neighbor in the grid.
"""
-
+
x = grid_mm[:, 0, 0, 0]
y = grid_mm[0, :, 0, 1]
z = grid_mm[0, 0, :, 2]
- xx = int(np.argmin((x - point_mm[0])**2))
- yy = int(np.argmin((y - point_mm[1])**2))
- zz = int(np.argmin((z - point_mm[2])**2))
+ xx = int(np.argmin((x - point_mm[0]) ** 2))
+ yy = int(np.argmin((y - point_mm[1]) ** 2))
+ zz = int(np.argmin((z - point_mm[2]) ** 2))
- return np.array([xx, yy, zz], dtype=np.int32)
\ No newline at end of file
+ return np.array([xx, yy, zz], dtype=np.int32)
diff --git a/rq_controller/common/volume.py b/rq_controller/common/volume.py
index ac1b645..b63aea9 100644
--- a/rq_controller/common/volume.py
+++ b/rq_controller/common/volume.py
@@ -19,7 +19,7 @@ class VOLUME_TYPES(IntEnum):
UINT_8 = 1
-class PyVolume():
+class PyVolume:
"""
Represents a volumetric dataset with an associated region of interest.
@@ -29,7 +29,9 @@ class PyVolume():
data_typ (VOLUME_TYPES): The data type of the volume.
"""
- def __init__(self, array: ndarray, roi: PyRegionOfIntrest, data_type: VOLUME_TYPES = ...):
+ def __init__(
+ self, np_array: ndarray, roi: PyRegionOfIntrest, data_type: VOLUME_TYPES = ...
+ ):
"""
Initializes a PyVolume instance.
@@ -40,7 +42,7 @@ class PyVolume():
"""
self.roi = roi
- self.array = array
+ self.array = np_array
self.data_typ = data_type
@staticmethod
@@ -60,8 +62,8 @@ class PyVolume():
elif volume_type == VOLUME_TYPES.UINT_8:
return np.uint8
else:
- raise ValueError('Datatype is not implemented')
-
+ raise ValueError("Datatype is not implemented")
+
@staticmethod
def enum_to_numpify(volume_type: VOLUME_TYPES) -> str:
"""
@@ -75,14 +77,14 @@ class PyVolume():
"""
if volume_type == VOLUME_TYPES.UINT_16:
- return 'mono16'
+ return "mono16"
elif volume_type == VOLUME_TYPES.UINT_8:
- return 'mono8'
+ return "mono8"
else:
- raise ValueError('Datatype is not implemented')
-
+ raise ValueError("Datatype is not implemented")
+
@classmethod
- def dummy(cls) -> 'PyVolume':
+ def dummy(cls) -> "PyVolume":
"""
Creates a dummy instance of PyVolume for testing.
@@ -91,12 +93,12 @@ class PyVolume():
"""
roi = PyRegionOfIntrest.dummy()
- array = np.random.randint(0, 255, size=roi.shape)
+ np_array = np.random.randint(0, 255, size=roi.shape)
data_type = VOLUME_TYPES.UINT_8
- return cls(array, roi, data_type)
+ return cls(np_array, roi, data_type)
@classmethod
- def from_message(cls, msg: Volume) -> 'PyVolume':
+ def from_message(cls, msg: Volume) -> "PyVolume":
"""
Creates an instance of PyVolume from a ROS message.
@@ -108,33 +110,34 @@ class PyVolume():
"""
roi: Marker = msg.grid.region_of_intrest_stack.markers[0]
- center_points_mm = np.array([
- roi.pose.position.x,
- roi.pose.position.y,
- roi.pose.position.z])
-
- dimensions_mm = np.array([
- roi.scale.x,
- roi.scale.y,
- roi.scale.z])
-
+ center_points_mm = np.array(
+ [roi.pose.position.x, roi.pose.position.y, roi.pose.position.z]
+ )
+
+ dimensions_mm = np.array([roi.scale.x, roi.scale.y, roi.scale.z])
+
frame_id = roi.header.frame_id
- resolution_mm = np.array([
- msg.grid.resolution.x,
- msg.grid.resolution.y,
- msg.grid.resolution.z])
-
- py_roi = PyRegionOfIntrest(center_points_mm, dimensions_mm, frame_id, resolution_mm)
-
+ resolution_mm = np.array(
+ [msg.grid.resolution.x, msg.grid.resolution.y, msg.grid.resolution.z]
+ )
+
+ py_roi = PyRegionOfIntrest(
+ center_points_mm, dimensions_mm, frame_id, resolution_mm
+ )
+
data_typ = msg.datatype
- array = np.zeros(py_roi.shape, dtype=cls.get_data_type(data_typ))
+ np_array = np.zeros(py_roi.shape, dtype=cls.get_data_type(data_typ))
for i, slice in enumerate(msg.slices):
- array[:, :, i] = ros2_numpy.numpify(slice).reshape((py_roi.shape[0], py_roi.shape[1])).astype(cls.get_data_type(data_typ))
+ np_array[:, :, i] = (
+ ros2_numpy.numpify(slice)
+ .reshape((py_roi.shape[0], py_roi.shape[1]))
+ .astype(cls.get_data_type(data_typ))
+ )
+
+ return cls(np_array, py_roi, data_typ)
- return cls(array, py_roi, data_typ)
-
def as_message(self) -> Volume:
"""
Converts the PyVolume instance to a ROS message.
@@ -151,12 +154,15 @@ class PyVolume():
for z in range(self.array.shape[2]):
message.slices.append(
- ros2_numpy.msgify(Image,
- self.array[:, :, z].astype(self.get_data_type(self.data_typ)),
- self.enum_to_numpify(self.data_typ)))
-
+ ros2_numpy.msgify(
+ Image,
+ self.array[:, :, z].astype(self.get_data_type(self.data_typ)),
+ self.enum_to_numpify(self.data_typ),
+ )
+ )
+
return message
-
+
@property
def shape(self):
"""
@@ -165,10 +171,5 @@ class PyVolume():
Returns:
tuple: The shape of the volume.
"""
-
- return self.array.shape
-
-
-
-
+ return self.array.shape
diff --git a/rq_controller/rq_workflow.py b/rq_controller/rq_workflow.py
index f79cd44..d315759 100644
--- a/rq_controller/rq_workflow.py
+++ b/rq_controller/rq_workflow.py
@@ -5,55 +5,52 @@ from rq_ddetection.defect_detection_client import DefectDetectionClient
from rq_reconstruction.reconstruction_client import ReconstructionClient
from rq_trajectory.trajectory_optimization_client import TrajectoryOptimizationClient
-from rq_controller.common import PyProjection, PyRegionOfIntrest, PyVolume
+from rq_controller.common import PyProjection, PyRegionOfIntrest
import rclpy
-from rclpy.node import Node
-from scipy.spatial.transform import Rotation
-import numpy as np
-
-class WorkflowNode():
+class WorkflowNode:
def __init__(self):
-
self.hardware_interface = HardwareClient()
self.defect_detection_interface = DefectDetectionClient()
self.trajectory = TrajectoryOptimizationClient()
self.reconstruction = ReconstructionClient()
-
- def defect_detection(self, projections: list[PyProjection]) -> list[PyRegionOfIntrest]:
+ def defect_detection(
+ self, projections: list[PyProjection]
+ ) -> list[PyRegionOfIntrest]:
future = self.defect_detection_interface.multi_projection_defect_detection(
- projections)
-
+ projections
+ )
+
rclpy.spin_until_future_complete(self.defect_detection_interface, future)
response = future.result()
roi_list = self.defect_detection_interface.response_2_py(response)
return roi_list
-
+
def aquire_projection(self, projection: PyProjection):
future = self.hardware_interface.aquire_projection(projection)
-
+
rclpy.spin_until_future_complete(self.hardware_interface, future)
response = future.result()
projection = self.hardware_interface.projection_response_2_py(response)
return projection
-
+
def check_reachability(self, projection: PyProjection):
future = self.hardware_interface.check_reachability(projection)
-
+
rclpy.spin_until_future_complete(self.hardware_interface, future)
response = future.result()
reached, cost, _ = self.hardware_interface.reachability_response_2_py(response)
return reached, cost
-
+
def get_volume(self, projection_stack: list[PyProjection], roi: PyRegionOfIntrest):
future = self.reconstruction.get_volume(projection_stack, roi)
@@ -61,7 +58,7 @@ class WorkflowNode():
response = future.result()
return self.reconstruction.response_2_py(response)
-
+
def trajectory_update(self, current_projection: PyProjection):
future = self.trajectory.trajectory_update(current_projection)
@@ -69,43 +66,45 @@ class WorkflowNode():
response = future.result()
return self.trajectory.trajectory_update_response_2_py(response)
-
+
def trajectory_initialize(self, roi: list[PyRegionOfIntrest]):
future = self.trajectory.trajectory_initialize(roi)
rclpy.spin_until_future_complete(self.trajectory, future)
-
def main():
- print('This minimal example need the nodes described in the rq_workflow/launch/echo_launch.py script.')
+ print(
+ "This minimal example need the nodes described in the rq_workflow/launch/echo_launch.py script."
+ )
rclpy.init()
workflow = WorkflowNode()
- print('Aquire some scout views...')
+ print("Aquire some scout views...")
projection_list = list()
for i in range(5):
- print(f' - At projection {i}')
+ print(f" - At projection {i}")
scan_pose = PyProjection.dummy()
scan_pose.focal_spot_mm += i
projection_list.append(workflow.aquire_projection(scan_pose))
- print('Detect errors in scout views ...')
+ print("Detect errors in scout views ...")
roi = workflow.defect_detection(projection_list)
- print('Init traj opt ...')
+ print("Init traj opt ...")
workflow.trajectory_initialize(roi)
- print('Get next scan pose from traj opt ...')
+ print("Get next scan pose from traj opt ...")
next_scan_pose, finished = workflow.trajectory_update(projection_list[-1])
- print('Aquire scan pose ...')
+ print("Aquire scan pose ...")
projection_list.append(workflow.aquire_projection(next_scan_pose))
- print('Resconstruct projections ...')
- volume = workflow.get_volume(projection_list, roi[0])
+ print("Resconstruct projections ...")
+ workflow.get_volume(projection_list, roi[0])
+
+ print("FINISHED !!!")
- print('FINISHED !!!')
-if __name__ == '__main__':
- main()
\ No newline at end of file
+if __name__ == "__main__":
+ main()
diff --git a/rq_controller/tf2/static_broadcaster.py b/rq_controller/tf2/static_broadcaster.py
index 39f5cd9..5becb1f 100644
--- a/rq_controller/tf2/static_broadcaster.py
+++ b/rq_controller/tf2/static_broadcaster.py
@@ -1,9 +1,5 @@
-import math
-import sys
-
from geometry_msgs.msg import TransformStamped
-import numpy as np
import rclpy
from rclpy.node import Node
@@ -20,13 +16,22 @@ class StaticFramePublisher(Node):
time.
"""
- def __init__(self, frame, position, quaternion, name: str = 'static_broadcaster', parent_frame: str = 'world'):
+ def __init__(
+ self,
+ frame,
+ position,
+ quaternion,
+ name: str = "static_broadcaster",
+ parent_frame: str = "world",
+ ):
super().__init__(name)
self.tf_static_broadcaster = StaticTransformBroadcaster(self)
# Publish static transforms once at startup
- self.make_transforms(frame, position.split(" "), quaternion.split(" "), parent_frame)
+ self.make_transforms(
+ frame, position.split(" "), quaternion.split(" "), parent_frame
+ )
def make_transforms(self, frame, position, quaternion, parent_frame):
t = TransformStamped()
@@ -47,27 +52,22 @@ class StaticFramePublisher(Node):
def main(args=None):
- logger = rclpy.logging.get_logger('logger')
+ rclpy.logging.get_logger("logger")
rclpy.init(args=args)
- node = rclpy.create_node('static_broadcaster')
- parent_frame = node.declare_parameter('parent_frame', 'world').value
- frame = node.declare_parameter('frame', 'object').value
- name = node.declare_parameter('name', 'static_broadcaster').value
- position = node.declare_parameter('position', '0 0 0').value
- quaternion = node.declare_parameter('quaternion', '0 0 0 1').value
+ node = rclpy.create_node("static_broadcaster")
+ parent_frame = node.declare_parameter("parent_frame", "world").value
+ frame = node.declare_parameter("frame", "object").value
+ name = node.declare_parameter("name", "static_broadcaster").value
+ position = node.declare_parameter("position", "0 0 0").value
+ quaternion = node.declare_parameter("quaternion", "0 0 0 1").value
+
+ node = StaticFramePublisher(frame, position, quaternion, name, parent_frame)
- node = StaticFramePublisher(
- frame,
- position,
- quaternion,
- name,
- parent_frame)
-
try:
rclpy.spin(node)
except KeyboardInterrupt:
pass
- rclpy.shutdown()
\ No newline at end of file
+ rclpy.shutdown()
diff --git a/setup.py b/setup.py
index 0b679c3..37ee73e 100644
--- a/setup.py
+++ b/setup.py
@@ -1,28 +1,25 @@
from setuptools import find_packages, setup
-package_name = 'rq_controller'
+package_name = "rq_controller"
setup(
name=package_name,
- version='0.0.0',
- packages=find_packages(exclude=['test']),
+ version="0.0.0",
+ packages=find_packages(exclude=["test"]),
data_files=[
- ('share/ament_index/resource_index/packages',
- ['resource/' + package_name]),
- ('share/' + package_name, ['package.xml']),
+ ("share/ament_index/resource_index/packages", ["resource/" + package_name]),
+ ("share/" + package_name, ["package.xml"]),
],
- install_requires=['setuptools',
- 'Pillow',
- 'pyometiff'],
+ install_requires=["setuptools", "Pillow", "pyometiff"],
zip_safe=True,
- maintainer='root',
- maintainer_email='simon.wittl@th-deg.de',
- description='TODO: Package description',
- license='TODO: License declaration',
- tests_require=['pytest'],
+ maintainer="root",
+ maintainer_email="simon.wittl@th-deg.de",
+ description="TODO: Package description",
+ license="TODO: License declaration",
+ tests_require=["pytest"],
entry_points={
- 'console_scripts': [
- 'tf_static_broadcaster = rq_controller.tf2.static_broadcaster:main',
+ "console_scripts": [
+ "tf_static_broadcaster = rq_controller.tf2.static_broadcaster:main",
],
},
)
diff --git a/test/__pycache__/test_base_loader.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_base_loader.cpython-38-pytest-8.2.2.pyc
index 279c0db1aec0f0f5b456424894890499d32a6041..49fe03382c5c64fcf5b5890c4cdc5cd6c09d5e4d 100644
GIT binary patch
delta 82
zcmbO(HeHN2l$V!_0R(EJ(ywpioyExLJb4A9A0yl5?~Dgo7zH-(WYcD36rcQ*eedKv
jPQJ+-IQB6rPR{4t%BVJ3mFp=lGYcaZCm%Z>D+mGrqe&Fr
delta 80
zcmbO(HeHN2l$V!_0SKOoPDnekk#`m&WAfw`jDC!)o4+$2WMSmnypv6vkx^vwQ}(@#
i5|bBmoMx1noX@$HQDL$w*Hd057Dg@(J~loU5Cj00cod5O
diff --git a/test/__pycache__/test_base_writer.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_base_writer.cpython-38-pytest-8.2.2.pyc
index 29e343a89d1a629bacda3ebb8b0f24f419a5fc0e..1d58ab39dfe5e08797f2dc9b57d4f0e5bc24e22c 100644
GIT binary patch
delta 262
zcmewr)E3Ma%FD~e00Om9>AM9t@@X<LI#0G>@?+%L+|IO%g;8v?6T2g$uq;qTF<2oZ
z4<idB8w1<_$rCsZGpbAu;k+xXiAC0qYd538=3iWgm>5kb-xrtNe2aHJ6QlLyd{NoW
z(*;tPCeM<Q+bk&@%EaioIbSrNi7{~VeepCV#z?S=WGQnd#ssjw9WvTXjA>v|M)@Wt
z#_Y-WRpmD?R%B*kECe%;DN8UhmT$hVD#pZE3l<U8uwztb<6&lD<l^LD2SQdbW&_fk
N93a5X0b;X(AON|#JYE0*
delta 256
zcmZn*{uRU*%FD~e00dXXCZv53*vO~J#F#wUg2|7OZF4)*E*3`q%}(r&jQpZNCB-Zt
zg^WCmMS7EcxY8#7<A`RIoE*h@msb{9cCr`OZbrq;Y}|*K7*!{~7MI=pjCVd0qt@gP
za<ZEj3#2eH>VZX7g+rMbjlrTbM1z<Z%{RXmPh(=V0gL2InKMmh7na+6L`Iv5(RK3&
zIiL}qn<pqLF){j0o}ehd`I52(6Js!#$))z4kud_yRMfCzRA=O2VqxUs;9%omfkIXw
Jjfz=0SOL)zJTw3R
diff --git a/test/__pycache__/test_projection.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_projection.cpython-38-pytest-8.2.2.pyc
index 8413a88371ec487791bfb98a4279f60cf8b3edae..cb9728ada1db97c0497e0512d7c4c04df1beda91 100644
GIT binary patch
delta 3507
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
delta 4107
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
C4A|5F
diff --git a/test/__pycache__/test_projection_geometry.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_projection_geometry.cpython-38-pytest-8.2.2.pyc
index daecbc751bbc7609edc20368ee278eb37f545dfe..e30f6eb8b6c80bf2b52bcc7c18ee64568b1a801f 100644
GIT binary patch
delta 450
zcmYk(%}WAN5CHI<^=s8!O;REy1=)5b?ZfOtDoaf*^6R1pk)lIHbja2q45AK2f4~Uc
zJ9m-2)v0TT&an^$o}yFdF1;~`-oWq8do#@8y|>0^L##R+HjdU=ea|X(#X1ieZJ+N6
zpkvWK74oxEYl|Ad#lj6naPvI;#kWzwj(y%~FmnQD=9=69Cvs{`)9sHYi*9VTr(?Qy
zJ9uY+IF>zmFyM_R1bOYj^KPuou(7I#@Dg#xheE`NCAwQ6fR2QkAXW%7F-j~F{pMxL
zlK3@p8Awr@CNjhtF-c^J9CmyXr19Q&02OV_-?hRzzDOs&B&(i^JFV8PdK{FLW;+pX
z=?1o`8~7>}@k#b#Ps*dDII$SE;FX-kL)i%hJeTWGWNvDbq5zb%QaH|=%50vF*W(vK
z-M-pvZ~so7`+t~KbNwbc5`}_Rjrag+coc204|tBIT=W!bo~RHt3``^}L&C5i3br5L
Ce`;|6
delta 482
zcmZ9}OG`pQ6ae6RuCHt6Bg2Xelft|=--?!LrD<822vIF=LP!)u8@aYo2wJo+IDbHB
z*#qSMf;ROJg4`4cf%F@K=Gdm1fp5;7b7p2SpOv?YW!G#T;Mll-y*j=&w=FUchw2I6
z6+p(4DLm?AwfZ)7fQ?N%Xu;0gcx;*Gtf1!vPS4f2LC(S{5%t6Ls58jgS|bvb)rX-w
z4b0-cqX2+6j%moN&yIKPUX)#>IEWD<#^{Lz6?$pP#R;G-p(KcYK~Is3m?x6N0+GV6
z@yp323YUotktIUJ3X#K>(*rSla-Kp-jZU<U=2gnmeG)Wxuqp-7HM2OCVu_}uTCX1|
zXKs&JYb2$*tYM3?_P2EmU%XbK@IUGHT45c-UKuu+MQVagiqwcG0*1T>EQm$*R_cOo
ziyf8`eHU)ol&LiieqK#<er@7PuHO{%2OzCh{Z4=~o(C%IgF1n%Ey9XQo+uGz^aYcK
KVZkaG1>-lW*lqU!
diff --git a/test/__pycache__/test_region_of_intrest.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_region_of_intrest.cpython-38-pytest-8.2.2.pyc
index 469b57f673dd3002e757812d9c29a8ea600abac0..cdd2ab3fba79761b42e2adb2ccc1cc222fb2eecd 100644
GIT binary patch
delta 357
zcmbQ1G%blQl$V!_0R(EJ(z*FI@})5`I!`WT3TEWme3HqVol#-4C|48<qu%BMzFF*y
zW}CUiQg|6}O)gM2Vzi&USotnv{N_d#1xBFIBGm@Q;K>`*r5TeZH>&KJ{9A1*W8&nA
z>T-+`VA1r=XVm+cq>_Pl6{UcPR1jegA~Zon+U621W=4@)ECrQ@#+uA8{{ul$7Dy&*
za<{e;(1vx|L5vxb8Ffs6Y%?88#@NXPI)<XmYz!O>Yz$mLk_$+;G4L@I<!;`lGmlX;
z53CzR*nx<A5K%BWQ|~&^07rcb(Oc~4MVTq_xw*GE3i31aN`S1QlF5DgR*YGbPwFc(
zR!@GbAHx_m*~`EPsH4`vN;Dp1L=uQd2NAg-qI&Wf17mS!9!4H!7Dg^n4n7VJ4o(gc
J4pt!K1ptOoV2l6&
delta 357
zcmbQ1G%blQl$V!_0SFQv^`|}J-N={5#F#v}lqr~zee+2sZ+1qR&7xdUER33)3;1TS
zGa78>7E9q}jGA1aY{Y0Wd9m_c#<<OmDhiB1p+%|<jNX$ss7o^@Om0-!Gx@jLRL1zp
z6V>Gy{lTKCo6o5CF-au?Eh|a_5y>FJ9z<w@h?LDGTFi_hQ7i?OhQ^xAFaHBUQ94K_
zeR8+963~Wq+ChwIlNohPfNV1zOUB^I1v-YJjBE@X3~UTsK#~hcw=wWB6lHAQrZbOG
zG!v{FMA(6dED(`BIaBXC&;Un$3(+X{^rFm^_}ttmj)MHmyb>U*D1UOFz7=Ei<dgc!
zjK!1R>c=qNn(Sp@1k_P$U?my{G9m#)q=JYH5K%n&jDfK@BM&1F6AL4k2nR0*I|m1c
KFb4||asUADj$PUS
diff --git a/test/__pycache__/test_volume.cpython-38-pytest-8.2.2.pyc b/test/__pycache__/test_volume.cpython-38-pytest-8.2.2.pyc
index e4329085a29c878eed2392f2e4b4eda540f9cb6f..f39dd0ea1a983260f04c5ddbbe585720a430ed67 100644
GIT binary patch
delta 2064
zcmb7FOK%%h6!x{9di;tV6T9R=;y8)Igpk(G11C+Jv}s78rKAx~ThnGb#S=5aFYb(`
zI3@CmN(fW|S8TdK?XnvX@{$cJkl1vEght))8(<Y7!Ts(;$vA4IG?6~vIrp41=R2=?
zw)$)}oC}8oF8uB0i$DAn{@qP1_NP1Tv%E#B7c3U_>~hHi&l~+RSF(tn_v>Y~s3~Qm
z_{2pgxo|JL%>M9PBAsl&n<l4QYu>-zB*iZJs$<jqn$Ez`Q)^7`bgG7-Q8PLEdaW@l
z8#K#ro{*g@?5|)S+l)@GX9K&`3!#@Dn9{Rw0@XdIeU{tLaiN@`9{yu>6zb)2gQlQ7
z3>X1Su(~u(rr0B?Miy9?e>k`R@f0A#7X76WFc388DSonEF*U<f^onlkYDwQwO}$!~
zU{C#L$VMv|_?eJ-_FM3Ne}?PIC!QB1onv}vsCf=<L4_^?mH;B$D0Sm}9w5S)z)3{4
ziqjRq3gB(PCBQp?cLA3H?*WAGWqy(a6w%PDfOWu{%N2E5!KGS5u@gQ=bF3$vjDLXJ
zYXAppb~T(JvrG%0BDY)Lg~#2T;xCc4n4s8J2bPMOK?fc7IQmKRki*M|pF}8vdM`h5
zBBvo}XXE5COLJVomTXmNSv9ll%dW@^c>UOwAZOXHU5lj9IuZK<yuR+v#mDiEqm^NM
z-FM<>IW%gT&O+xcz#OZ_<K#N~JbtT*-m-#5N&iSwR7%x`+~MeeLz_*m$J<iW`3`IX
zs-cuM!{Bp6hq%CgeG;eRCXG*D(?vCS^J|rQS);0{(J?&x_+w4q+VA~~@QR|yU5<1L
z(xO9<LAy;3y1|*^41FI8yoFp;1$+p2lS6*SZ&T-!Pm7S=1vom1KUxtnKZkr*Sog{E
zq}19txr_ol?0GbbG|IjgW{xWG!<61c!1D59Ovz;DEB3f&lPwKKSfsa~Nqv!ZD_qn}
zrJ$OsVm4};BcpInM*+vpEvATGV0vFFB2pwW0P+@l*w?#cg)m8Wzoj#6Pt!-~#{~Vh
z(5|t6`ew*>YrOwoBF%HJoR7i2iBGc5!3_JaC(6Dbh-MDgU3(wV>j>@!;3gvKC|4`h
zEO$ZoU95zv@M*6Vp0>e6GYRdNBL68YD8S&ri_@M5n#WZgAll&;PDcvgEtsP<LyB2d
z_IvWix5*iDuQi(tkYE~CVZc1QJhavnb1v40W2f+IIVLu`y&^?59s3;S7XWU+!4f<!
zU0JgC4S($!=cakiR2(H35Cn~n)taWTTxu}(8Dbr<q`P&!Wa<@zuCV*5sf0*85^8lI
z3HDg#+0)cb{vnlz`<qt8&?-ii;uC62Vw!y5G6oahmcDJ)sb-Jv2IRK^1waX~4Y&uu
z`yD}wdWdhBv{0@V>Lu+Q;TpyW2gwz4Nkk%1Z-~4aBKVg)UJ`gs3P?Ull0qDP{{zJW
BwnhK|
delta 2064
zcmb7FOK%%h6!wjsdi<&%#4e80*l`=kBqhN~Y`IOzqYqMOiP97oGK4tOW|9u^OLxW+
zj#PO?B?N-P6`L+lyFuy-Aurjm0*OsmNNCgz`~_G=mEeANqGS@aQkun=d(XZ1%=ymw
z&hgXvr}LpwDCBqXzrUY-z460Oq2IfR!v5^ac@@tl)z=jkao^>ZuiPVjgZ!37bj7Dv
z)lIEjH8vl+=rA|#6mPRX+*e3|^?P#UOlQ&aPZvqEOWykHZ}MZB!$WtYHMxCUH4KfK
znZcn(s~{V6lAk;#+t=7%ffQSfj4l=Zcc}+P58Zo8&%z0=?l|8U`TIOK$_eV`|E%uy
zX0_U)X<W_#1^`2>DGie`_E2h&B8&P?1&T0_0Y=%3uW}j;1PwaESJo@0W|(EYrklE2
z(YIAouh(Su#5YBjIsyOBgcR6sfqQ+U{H}cLc|p=V(}M%;b8rhPbP8}DAi|B%F09`I
zh%kn*5>Z{m>Iz^EZ~<@$a2fD6U>@)eK=_{FE7?yG4Sg4|0J!FIMO;>3w$Uov2|r7(
zvt%d}U&QHq00(Qf5K52<riI4Ha_76ya2KceOL#FRC?2Q-%SOzAgARKX*=p}|c=_;8
zA{0SA$yc1n85j<-aq=k8>->Uk*{IX1Y8KfS(eMj+{TNM<bL`jX3|Z?Oi+v7W_j^k5
z*YJ(Qm0>$QYjH?U;X=*Paom{z<XJr)CpXw<@s&2TWd)3iep@T6l&USc+o6E{HwwSU
zWhv^sf;WEEC|5PZ;C(~;;Z=NIus>?jc=xqkRE0O6R%=!@s+t--&G(9zZyWl?uJ&i)
zA4QR)j&usrLLtbYEt5SpC=RKN)2q0^CFG(X13m!A9F)Azrp`N`-hy=%;7}6ZT4B*Y
z`+P63o)dFK>)bqX5e0aVd^m_S%H9`dj()_?6;|#|_!SQ?#)M3^zhsY+t86wMX5rpG
zCZ)nlN@!Cv%j>GCmd#c}b7WLZfGk2gYHra*beid@Y*?g7WB}w9_8`?es|3+Ww%&5%
z2X>Q(>Bj{91EDRje^Ys~)fw)4Mx+Aw%J~@VoA@X@o*rlaB_r(n{>b?LxI3sLdIQ0|
z4=5p`?rObOFLD=j*Tv=F27KCMg{Li@Xup)O1o=()zXQ<W%xe#my*$vHIQj%2<nSR@
zhYH^#m_wSuvRN<hYO?fgCQmAzLdH)5Z{Sr3P+(UF7TcoF#rSZ{6n-qn#6-78q^M>F
zkL-Dl)igkK*WM63YOQ6-o;UonQ_e~AoUS-b&@TuYchrWq!b;h6tjfcX`z`5KQ?HnM
z&7gDaUUniORELCG-AIDnmKJ-GUFJWe@~OVI5;nA&QK$F`HAc}*UJybrTiy-*Q?p4m
zyLFdfUk0oJG{6?10>JkjL5g~eaGNEauh!R_6>XaEodLg+E9R1jL?R?eUJY^x63Oi$
P{*#hl@=B5v<mmk$#$u~_
diff --git a/test/test_base_loader.py b/test/test_base_loader.py
index eb1c071..d00fcbc 100644
--- a/test/test_base_loader.py
+++ b/test/test_base_loader.py
@@ -2,33 +2,39 @@ import pytest
from rq_controller.common.io.loader import BaseDataLoader
from pathlib import Path
+
@pytest.fixture
def base_data_loader():
return BaseDataLoader(
porjection_geometry_suffix="geometry_suffix",
projection_suffix="projection_suffix",
region_of_intrest_suffix="roi_suffix",
- volume_suffix="volume_suffix"
+ volume_suffix="volume_suffix",
)
+
def test_initialization(base_data_loader: BaseDataLoader):
assert base_data_loader.porjection_geometry_suffix == "geometry_suffix"
assert base_data_loader.projection_suffix == "projection_suffix"
assert base_data_loader.region_of_intrest_suffix == "roi_suffix"
assert base_data_loader.volume_suffix == "volume_suffix"
+
def test_load_projection_geometry_not_implemented(base_data_loader: BaseDataLoader):
with pytest.raises(NotImplementedError):
base_data_loader.load_projection_geometry(Path("/fake/path"))
+
def test_load_projection_not_implemented(base_data_loader: BaseDataLoader):
with pytest.raises(NotImplementedError):
base_data_loader.load_projection(Path("/fake/path"))
+
def test_load_region_of_intrest_not_implemented(base_data_loader: BaseDataLoader):
with pytest.raises(NotImplementedError):
base_data_loader.load_region_of_intrest(Path("/fake/path"))
+
def test_load_volume_not_implemented(base_data_loader: BaseDataLoader):
with pytest.raises(NotImplementedError):
- base_data_loader.load_volume(Path("/fake/path"))
\ No newline at end of file
+ base_data_loader.load_volume(Path("/fake/path"))
diff --git a/test/test_base_writer.py b/test/test_base_writer.py
index 3d41a2d..d0896df 100644
--- a/test/test_base_writer.py
+++ b/test/test_base_writer.py
@@ -1,91 +1,128 @@
import pytest
from pathlib import Path
-from rq_controller.common import PyProjection, PyProjectionGeometry, PyRegionOfIntrest, PyVolume
+from rq_controller.common import (
+ PyProjection,
+ PyProjectionGeometry,
+ PyRegionOfIntrest,
+ PyVolume,
+)
from rq_controller.common.io.writer import BaseDataWriter
+
@pytest.fixture
def base_data_writer():
return BaseDataWriter(
porjection_geometry_suffix=".geom",
projection_suffix=".proj",
region_of_intrest_suffix=".roi",
- volume_suffix=".vol"
+ volume_suffix=".vol",
)
+
def test_initialization(base_data_writer):
assert base_data_writer.porjection_geometry_suffix == ".geom"
assert base_data_writer.projection_suffix == ".proj"
assert base_data_writer.region_of_intrest_suffix == ".roi"
assert base_data_writer.volume_suffix == ".vol"
+
def test_write_projection_geometry_not_implemented(base_data_writer):
with pytest.raises(NotImplementedError):
- base_data_writer.write_projection_geometry(Path("/fake/path"), PyProjectionGeometry.dummy())
+ base_data_writer.write_projection_geometry(
+ Path("/fake/path"), PyProjectionGeometry.dummy()
+ )
+
def test_write_projection_not_implemented(base_data_writer):
with pytest.raises(NotImplementedError):
base_data_writer.write_projection(Path("/fake/path"), PyProjection.dummy())
+
def test_write_region_of_intrest_not_implemented(base_data_writer):
with pytest.raises(NotImplementedError):
- base_data_writer.write_region_of_intrest(Path("/fake/path"), PyRegionOfIntrest.dummy())
+ base_data_writer.write_region_of_intrest(
+ Path("/fake/path"), PyRegionOfIntrest.dummy()
+ )
+
def test_write_volume_not_implemented(base_data_writer):
with pytest.raises(NotImplementedError):
base_data_writer.write_volume(Path("/fake/path"), PyVolume.dummy())
+
def test_get_next_projection_save_path(base_data_writer, tmp_path):
(tmp_path / "projection_00001.proj").touch()
expected_path = tmp_path / "projection_00002.proj"
assert base_data_writer.get_next_projection_save_path(tmp_path) == expected_path
+
def test_get_projection_save_path_i(base_data_writer, tmp_path):
expected_path = tmp_path / "projection_00005.proj"
assert base_data_writer.get_projection_save_path_i(tmp_path, 5) == expected_path
+
def test_get_next_projection_geometry_save_path(base_data_writer, tmp_path):
(tmp_path / "geometry_00001.geom").touch()
expected_path = tmp_path / "geometry_00002.geom"
- assert base_data_writer.get_next_projection_geometry_save_path(tmp_path) == expected_path
+ assert (
+ base_data_writer.get_next_projection_geometry_save_path(tmp_path)
+ == expected_path
+ )
+
def test_get_projection_geometry_save_path_i(base_data_writer, tmp_path):
expected_path = tmp_path / "geometry_00005.geom"
- assert base_data_writer.get_projection_geometry_save_path_i(tmp_path, 5) == expected_path
+ assert (
+ base_data_writer.get_projection_geometry_save_path_i(tmp_path, 5)
+ == expected_path
+ )
+
def test_get_next_region_of_intrest_save_path(base_data_writer, tmp_path):
(tmp_path / "roi_00001.roi").touch()
expected_path = tmp_path / "roi_00002.roi"
- assert base_data_writer.get_next_region_of_intrest_save_path(tmp_path) == expected_path
+ assert (
+ base_data_writer.get_next_region_of_intrest_save_path(tmp_path) == expected_path
+ )
+
def test_get_region_of_intrest_save_path_i(base_data_writer, tmp_path):
expected_path = tmp_path / "roi_00005.roi"
- assert base_data_writer.get_region_of_intrest_save_path_i(tmp_path, 5) == expected_path
+ assert (
+ base_data_writer.get_region_of_intrest_save_path_i(tmp_path, 5) == expected_path
+ )
+
def test_get_next_volume_save_path(base_data_writer, tmp_path):
(tmp_path / "volume_00001.vol").touch()
expected_path = tmp_path / "volume_00002.vol"
assert base_data_writer.get_next_volume_save_path(tmp_path) == expected_path
+
def test_get_volume_save_path_i(base_data_writer, tmp_path):
expected_path = tmp_path / "volume_00005.vol"
assert base_data_writer.get_volume_save_path_i(tmp_path, 5) == expected_path
+
def test_number_of_projection_geometries(base_data_writer, tmp_path):
(tmp_path / "geometry_00001.geom").touch()
(tmp_path / "geometry_00002.geom").touch()
assert base_data_writer.number_of_projection_geometries(tmp_path) == 2
+
def test_number_of_projections(base_data_writer, tmp_path):
(tmp_path / "projection_00001.proj").touch()
(tmp_path / "projection_00002.proj").touch()
assert base_data_writer.number_of_projections(tmp_path) == 2
+
def test_number_of_region_of_intrests(base_data_writer, tmp_path):
(tmp_path / "roi_00001.roi").touch()
(tmp_path / "roi_00002.roi").touch()
assert base_data_writer.number_of_region_of_intrests(tmp_path) == 2
+
def test_number_of_volumes(base_data_writer, tmp_path):
(tmp_path / "volume_00001.vol").touch()
(tmp_path / "volume_00002.vol").touch()
- assert base_data_writer.number_of_volumes(tmp_path) == 2
\ No newline at end of file
+ assert base_data_writer.number_of_volumes(tmp_path) == 2
diff --git a/test/test_projection.py b/test/test_projection.py
index 06075e4..0ccf386 100644
--- a/test/test_projection.py
+++ b/test/test_projection.py
@@ -1,10 +1,13 @@
import pytest
import numpy as np
-from rq_controller.common import PyProjection # Adjust this import according to your module's path
+from rq_controller.common import (
+ PyProjection,
+) # Adjust this import according to your module's path
from rq_interfaces.msg import Projection
from sensor_msgs.msg import Image
import ros2_numpy
+
@pytest.fixture
def example_message():
msg = Projection()
@@ -23,10 +26,10 @@ def example_message():
msg.projection_geometry.focal_spot_orientation_quad.z = 0.0
msg.projection_geometry.focal_spot_orientation_quad.w = 1.0
msg.projection_geometry.header.frame_id = "test_frame"
-
+
image_array = np.zeros((10, 10), dtype=np.uint16)
- msg.image = ros2_numpy.msgify(Image, image_array, encoding='mono16')
-
+ msg.image = ros2_numpy.msgify(Image, image_array, encoding="mono16")
+
msg.detector_heigth_mm = 100.0
msg.detector_width_mm = 200.0
msg.voltage_kv = 120.0
@@ -34,6 +37,7 @@ def example_message():
msg.exposure_time_ms = 500.0
return msg
+
def test_initialization():
focal_spot_mm = np.array([1.0, 2.0, 3.0])
detector_postion_mm = np.array([4.0, 5.0, 6.0])
@@ -47,12 +51,28 @@ def test_initialization():
frame_id = "test_frame"
focal_spot_orientation_quad = np.array([0.0, 0.0, 0.0, 1.0])
- projection = PyProjection(focal_spot_mm, detector_postion_mm, detector_orientation_quad, image, detector_heigth_mm, detector_width_mm, frame_id, focal_spot_orientation_quad, voltage_kv, current_ua, exposure_time_ms)
+ projection = PyProjection(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ image,
+ detector_heigth_mm,
+ detector_width_mm,
+ frame_id,
+ focal_spot_orientation_quad,
+ voltage_kv,
+ current_ua,
+ exposure_time_ms,
+ )
assert np.array_equal(projection.focal_spot_mm, focal_spot_mm)
assert np.array_equal(projection.detector_postion_mm, detector_postion_mm)
- assert np.array_equal(projection.detector_orientation_quad, detector_orientation_quad)
- assert np.array_equal(projection.focal_spot_orientation_quad, focal_spot_orientation_quad)
+ assert np.array_equal(
+ projection.detector_orientation_quad, detector_orientation_quad
+ )
+ assert np.array_equal(
+ projection.focal_spot_orientation_quad, focal_spot_orientation_quad
+ )
assert np.array_equal(projection.image, image)
assert projection.detector_heigth_mm == detector_heigth_mm
assert projection.detector_width_mm == detector_width_mm
@@ -61,25 +81,32 @@ def test_initialization():
assert projection.exposure_time_ms == exposure_time_ms
assert projection.frame_id == frame_id
+
def test_dummy_method():
projection = PyProjection.dummy()
assert np.array_equal(projection.focal_spot_mm, np.array([0.0, 100.0, 0.0]))
assert np.array_equal(projection.detector_postion_mm, np.array([0.0, -100.0, 0.0]))
- assert np.array_equal(projection.detector_orientation_quad, np.array([1.0, 0.0, 0.0, 1.0]))
- assert np.array_equal(projection.image, np.zeros((10, 10), dtype=np.uint16))
+ assert np.array_equal(
+ projection.detector_orientation_quad, np.array([1.0, 0.0, 0.0, 1.0])
+ )
assert projection.detector_heigth_mm == 10.0
assert projection.detector_width_mm == 10.0
assert projection.frame_id == "object"
+
def test_from_message(example_message):
projection = PyProjection.from_message(example_message)
assert np.array_equal(projection.focal_spot_mm, np.array([10.0, 20.0, 30.0]))
assert np.array_equal(projection.detector_postion_mm, np.array([40.0, 50.0, 60.0]))
- assert np.array_equal(projection.detector_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0]))
- assert np.array_equal(projection.focal_spot_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0]))
- assert np.array_equal(projection.image, np.zeros((10, 10), dtype=np.uint16))
+ assert np.array_equal(
+ projection.detector_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0])
+ )
+ assert np.array_equal(
+ projection.focal_spot_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0])
+ )
+
assert projection.detector_heigth_mm == 100.0
assert projection.detector_width_mm == 200.0
assert projection.voltage_kv == 120.0
@@ -87,6 +114,7 @@ def test_from_message(example_message):
assert projection.exposure_time_ms == 500.0
assert projection.frame_id == "test_frame"
+
def test_as_message(example_message):
projection = PyProjection.from_message(example_message)
msg = projection.as_message()
@@ -106,13 +134,16 @@ def test_as_message(example_message):
assert msg.projection_geometry.focal_spot_orientation_quad.z == 0.0
assert msg.projection_geometry.focal_spot_orientation_quad.w == 1.0
assert msg.projection_geometry.header.frame_id == "test_frame"
- assert np.array_equal(ros2_numpy.numpify(msg.image), np.zeros((10, 10), dtype=np.uint16))
+ assert np.array_equal(
+ ros2_numpy.numpify(msg.image), np.zeros((10, 10), dtype=np.uint16)
+ )
assert msg.detector_heigth_mm == 100.0
assert msg.detector_width_mm == 200.0
assert msg.voltage_kv == 120.0
assert msg.current_ua == 150.0
assert msg.exposure_time_ms == 500.0
+
def test_properties():
focal_spot_mm = np.array([1.0, 2.0, 3.0])
detector_postion_mm = np.array([4.0, 5.0, 6.0])
@@ -126,9 +157,21 @@ def test_properties():
frame_id = "test_frame"
focal_spot_orientation_quad = np.array([0.0, 0.0, 0.0, 1.0])
- projection = PyProjection(focal_spot_mm, detector_postion_mm, detector_orientation_quad, image, detector_heigth_mm, detector_width_mm, frame_id, focal_spot_orientation_quad, voltage_kv, current_ua, exposure_time_ms)
+ projection = PyProjection(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ image,
+ detector_heigth_mm,
+ detector_width_mm,
+ frame_id,
+ focal_spot_orientation_quad,
+ voltage_kv,
+ current_ua,
+ exposure_time_ms,
+ )
assert projection.detector_heigth_px == 20
assert projection.detector_width_px == 30
assert projection.pixel_pitch_x_mm == 200.0 / 30
- assert projection.pixel_pitch_y_mm == 100.0 / 20
\ No newline at end of file
+ assert projection.pixel_pitch_y_mm == 100.0 / 20
diff --git a/test/test_projection_geometry.py b/test/test_projection_geometry.py
index 7d4c44d..e28d1d9 100644
--- a/test/test_projection_geometry.py
+++ b/test/test_projection_geometry.py
@@ -1,29 +1,30 @@
import pytest
import numpy as np
from rq_interfaces.msg import ProjectionGeometry
-from rq_controller.common import PyProjectionGeometry
+from rq_controller.common import PyProjectionGeometry
@pytest.fixture
def example_message():
msg = ProjectionGeometry()
- msg.focal_spot_postion_mm.x = 10.
- msg.focal_spot_postion_mm.y = 20.
- msg.focal_spot_postion_mm.z = 30.
- msg.detector_postion_mm.x = 40.
- msg.detector_postion_mm.y = 50.
- msg.detector_postion_mm.z = 60.
- msg.detector_orientation_quad.x = 0.
- msg.detector_orientation_quad.y = 0.
- msg.detector_orientation_quad.z = 0.
- msg.detector_orientation_quad.w = 1.
- msg.focal_spot_orientation_quad.x = 0.
- msg.focal_spot_orientation_quad.y = 0.
- msg.focal_spot_orientation_quad.z = 0.
- msg.focal_spot_orientation_quad.w = 1.
+ msg.focal_spot_postion_mm.x = 10.0
+ msg.focal_spot_postion_mm.y = 20.0
+ msg.focal_spot_postion_mm.z = 30.0
+ msg.detector_postion_mm.x = 40.0
+ msg.detector_postion_mm.y = 50.0
+ msg.detector_postion_mm.z = 60.0
+ msg.detector_orientation_quad.x = 0.0
+ msg.detector_orientation_quad.y = 0.0
+ msg.detector_orientation_quad.z = 0.0
+ msg.detector_orientation_quad.w = 1.0
+ msg.focal_spot_orientation_quad.x = 0.0
+ msg.focal_spot_orientation_quad.y = 0.0
+ msg.focal_spot_orientation_quad.z = 0.0
+ msg.focal_spot_orientation_quad.w = 1.0
msg.header.frame_id = "test_frame"
return msg
+
def test_initialization():
focal_spot_mm = np.array([1.0, 2.0, 3.0])
detector_postion_mm = np.array([4.0, 5.0, 6.0])
@@ -31,22 +32,36 @@ def test_initialization():
frame_id = "test_frame"
focal_spot_orientation_quad = np.array([0.0, 0.0, 0.0, 1.0])
- geometry = PyProjectionGeometry(focal_spot_mm, detector_postion_mm, detector_orientation_quad, frame_id, focal_spot_orientation_quad)
+ geometry = PyProjectionGeometry(
+ focal_spot_mm,
+ detector_postion_mm,
+ detector_orientation_quad,
+ frame_id,
+ focal_spot_orientation_quad,
+ )
assert np.array_equal(geometry.focal_spot_mm, focal_spot_mm)
assert np.array_equal(geometry.detector_postion_mm, detector_postion_mm)
assert np.array_equal(geometry.detector_orientation_quad, detector_orientation_quad)
- assert np.array_equal(geometry.focal_spot_orientation_quad, focal_spot_orientation_quad)
+ assert np.array_equal(
+ geometry.focal_spot_orientation_quad, focal_spot_orientation_quad
+ )
assert geometry.frame_id == frame_id
+
def test_dummy_method():
geometry = PyProjectionGeometry.dummy()
assert np.array_equal(geometry.focal_spot_mm, np.array([1.0, 0.0, 0.0]))
assert np.array_equal(geometry.detector_postion_mm, np.array([-1.0, 0.0, 0.0]))
- assert np.array_equal(geometry.detector_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0]))
+ assert np.array_equal(
+ geometry.detector_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0])
+ )
assert geometry.frame_id == "object"
- assert np.array_equal(geometry.focal_spot_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0]))
+ assert np.array_equal(
+ geometry.focal_spot_orientation_quad, np.array([0.0, 0.0, 0.0, 1.0])
+ )
+
def test_from_message(example_message):
geometry = PyProjectionGeometry.from_message(example_message)
@@ -57,6 +72,7 @@ def test_from_message(example_message):
assert np.array_equal(geometry.focal_spot_orientation_quad, np.array([0, 0, 0, 1]))
assert geometry.frame_id == "test_frame"
+
def test_as_message(example_message):
geometry = PyProjectionGeometry.from_message(example_message)
msg = geometry.as_message()
diff --git a/test/test_region_of_intrest.py b/test/test_region_of_intrest.py
index 678f052..6774075 100644
--- a/test/test_region_of_intrest.py
+++ b/test/test_region_of_intrest.py
@@ -1,13 +1,16 @@
import pytest
import numpy as np
-from rq_controller.common import PyRegionOfIntrest # Adjust this import according to your module's path
+from rq_controller.common import (
+ PyRegionOfIntrest,
+) # Adjust this import according to your module's path
from rq_interfaces.msg import RegionOfIntrest
from visualization_msgs.msg import Marker
+
@pytest.fixture
def example_message():
msg = RegionOfIntrest()
-
+
marker = Marker()
marker.pose.position.x = 10.0
marker.pose.position.y = 20.0
@@ -16,15 +19,16 @@ def example_message():
marker.scale.y = 50.0
marker.scale.z = 60.0
marker.header.frame_id = "test_frame"
-
+
msg.region_of_intrest_stack.markers.append(marker)
-
+
msg.resolution.x = 0.1
msg.resolution.y = 0.1
msg.resolution.z = 0.1
-
+
return msg
+
def test_initialization():
center_points_mm = np.array([[1.0, 2.0, 3.0]])
dimensions_mm = np.array([[4.0, 5.0, 6.0]])
@@ -38,6 +42,7 @@ def test_initialization():
assert np.array_equal(roi.resolution_mm, resolution_mm)
assert roi.frame_id == frame_id
+
def test_dummy_method():
roi = PyRegionOfIntrest.dummy()
@@ -45,6 +50,7 @@ def test_dummy_method():
assert roi.dimensions_mm.shape == (1, 3)
assert roi.frame_id == "object"
+
def test_from_message(example_message):
roi = PyRegionOfIntrest.from_message(example_message)
@@ -53,6 +59,7 @@ def test_from_message(example_message):
assert np.array_equal(roi.resolution_mm, np.array([[0.1, 0.1, 0.1]]))
assert roi.frame_id == "test_frame"
+
def test_as_message(example_message):
roi = PyRegionOfIntrest.from_message(example_message)
msg = roi.as_message()
@@ -67,26 +74,34 @@ def test_as_message(example_message):
assert marker.scale.y == 50.0
assert marker.scale.z == 60.0
assert marker.header.frame_id == "test_frame"
-
+
assert msg.resolution.x == 0.1
assert msg.resolution.y == 0.1
assert msg.resolution.z == 0.1
+
def test_number_of_rois(example_message):
roi = PyRegionOfIntrest.from_message(example_message)
assert roi.number_of_rois == 1
+
def test_shape(example_message):
roi = PyRegionOfIntrest.from_message(example_message)
assert roi.shape == (399, 499, 599)
+
def test_get_grid(example_message):
roi = PyRegionOfIntrest.from_message(example_message)
grid = roi.get_grid(0)
assert grid.shape == (399, 499, 599, 3)
- assert np.array_equal(grid[0, 0, 0], np.array([10.0 - 20.0, 20.0 - 25.0, 30.0 - 30.0]))
- assert np.array_equal(grid[-1, -1, -1], np.array([10.0 + 20.0, 20.0 + 25.0, 30.0 + 30.0]))
+ assert np.array_equal(
+ grid[0, 0, 0], np.array([10.0 - 20.0, 20.0 - 25.0, 30.0 - 30.0])
+ )
+ assert np.array_equal(
+ grid[-1, -1, -1], np.array([10.0 + 20.0, 20.0 + 25.0, 30.0 + 30.0])
+ )
+
def test_next_neighbor():
grid_mm = np.zeros((20, 30, 40, 3))
diff --git a/test/test_volume.py b/test/test_volume.py
index e2a8ff8..a3c095b 100644
--- a/test/test_volume.py
+++ b/test/test_volume.py
@@ -1,6 +1,9 @@
import pytest
import numpy as np
-from rq_controller.common import PyVolume, PyRegionOfIntrest # Adjust this import according to your module's path
+from rq_controller.common import (
+ PyVolume,
+ PyRegionOfIntrest,
+) # Adjust this import according to your module's path
from rq_controller.common.volume import VOLUME_TYPES
from rq_interfaces.msg import Volume
from visualization_msgs.msg import Marker
@@ -22,19 +25,19 @@ def example_message():
marker.header.frame_id = "test_frame"
msg.grid.region_of_intrest_stack.markers.append(marker)
-
- msg.grid.resolution.x = 1.
- msg.grid.resolution.y = 1.
- msg.grid.resolution.z = 1.
+
+ msg.grid.resolution.x = 1.0
+ msg.grid.resolution.y = 1.0
+ msg.grid.resolution.z = 1.0
msg.datatype = VOLUME_TYPES.UINT_16
shape = (40, 50, 60)
slices = np.random.randint(0, 65535, size=shape, dtype=np.uint16)
for i in range(shape[2]):
- image_msg = ros2_numpy.msgify(Image, slices[:, :, i], encoding='mono16')
+ image_msg = ros2_numpy.msgify(Image, slices[:, :, i], encoding="mono16")
msg.slices.append(image_msg)
-
+
return msg
@@ -73,7 +76,7 @@ def test_as_message(example_message):
for i, slice_msg in enumerate(msg.slices):
slice_array = ros2_numpy.numpify(slice_msg)
assert np.array_equal(slice_array, volume.array[:, :, i])
-
+
def test_get_data_type():
assert PyVolume.get_data_type(VOLUME_TYPES.UINT_16) == np.uint16
@@ -83,8 +86,8 @@ def test_get_data_type():
def test_enum_to_numpify():
- assert PyVolume.enum_to_numpify(VOLUME_TYPES.UINT_16) == 'mono16'
- assert PyVolume.enum_to_numpify(VOLUME_TYPES.UINT_8) == 'mono8'
+ assert PyVolume.enum_to_numpify(VOLUME_TYPES.UINT_16) == "mono16"
+ assert PyVolume.enum_to_numpify(VOLUME_TYPES.UINT_8) == "mono8"
with pytest.raises(ValueError):
PyVolume.enum_to_numpify(-1)
@@ -95,4 +98,3 @@ def test_shape():
volume = PyVolume(array, roi, VOLUME_TYPES.UINT_8)
assert volume.shape == array.shape
-
--
GitLab