simind-python-connector 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- simind_python_connector/__init__.py +1 -1
- simind_python_connector/backends/__init__.py +7 -0
- simind_python_connector/builders/acquisition_builder.py +77 -29
- simind_python_connector/builders/image_builder.py +18 -6
- simind_python_connector/connectors/__init__.py +23 -4
- simind_python_connector/connectors/_spacing.py +13 -7
- simind_python_connector/connectors/python_connector.py +146 -27
- simind_python_connector/connectors/pytomography_adaptor.py +5 -0
- simind_python_connector/connectors/sirf_adaptor.py +3 -0
- simind_python_connector/connectors/stir_adaptor.py +3 -0
- simind_python_connector/converters/attenuation.py +3 -1
- simind_python_connector/converters/simind_to_stir.py +12 -10
- simind_python_connector/core/config.py +208 -66
- simind_python_connector/core/executor.py +36 -7
- simind_python_connector/utils/import_helpers.py +4 -0
- simind_python_connector/utils/interfile_numpy.py +18 -8
- simind_python_connector/utils/interfile_parser.py +4 -2
- simind_python_connector/utils/simind_utils.py +50 -11
- simind_python_connector/utils/stir_utils.py +7 -2
- {simind_python_connector-1.0.0.dist-info → simind_python_connector-1.1.0.dist-info}/METADATA +12 -3
- {simind_python_connector-1.0.0.dist-info → simind_python_connector-1.1.0.dist-info}/RECORD +24 -24
- {simind_python_connector-1.0.0.dist-info → simind_python_connector-1.1.0.dist-info}/WHEEL +1 -1
- {simind_python_connector-1.0.0.dist-info → simind_python_connector-1.1.0.dist-info}/licenses/LICENSE +0 -0
- {simind_python_connector-1.0.0.dist-info → simind_python_connector-1.1.0.dist-info}/top_level.txt +0 -0
|
@@ -19,6 +19,7 @@ Usage:
|
|
|
19
19
|
|
|
20
20
|
import importlib
|
|
21
21
|
import logging
|
|
22
|
+
import os
|
|
22
23
|
from typing import TYPE_CHECKING, Any, Literal, Optional, Union
|
|
23
24
|
|
|
24
25
|
from .base import AcquisitionDataInterface, ImageDataInterface
|
|
@@ -233,6 +234,9 @@ def create_image_data(
|
|
|
233
234
|
if isinstance(filepath_or_object, ImageDataInterface):
|
|
234
235
|
return filepath_or_object
|
|
235
236
|
|
|
237
|
+
if isinstance(filepath_or_object, os.PathLike):
|
|
238
|
+
filepath_or_object = os.fspath(filepath_or_object)
|
|
239
|
+
|
|
236
240
|
backend_hint = detect_image_backend(filepath_or_object)
|
|
237
241
|
if backend_hint is None:
|
|
238
242
|
backend_hint = detect_backend_from_interface(filepath_or_object)
|
|
@@ -314,6 +318,9 @@ def create_acquisition_data(
|
|
|
314
318
|
if isinstance(filepath_or_object, AcquisitionDataInterface):
|
|
315
319
|
return filepath_or_object
|
|
316
320
|
|
|
321
|
+
if isinstance(filepath_or_object, os.PathLike):
|
|
322
|
+
filepath_or_object = os.fspath(filepath_or_object)
|
|
323
|
+
|
|
317
324
|
backend_hint = detect_acquisition_backend(filepath_or_object)
|
|
318
325
|
if backend_hint is None:
|
|
319
326
|
backend_hint = detect_backend_from_interface(filepath_or_object)
|
|
@@ -97,6 +97,19 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
97
97
|
else:
|
|
98
98
|
self.pixel_array = np.array(self.pixel_array, dtype=np.float32)
|
|
99
99
|
|
|
100
|
+
expected_shape = (
|
|
101
|
+
1,
|
|
102
|
+
matrix_size_1,
|
|
103
|
+
num_projections,
|
|
104
|
+
matrix_size_2,
|
|
105
|
+
)
|
|
106
|
+
if self.pixel_array.shape != expected_shape:
|
|
107
|
+
raise ValueError(
|
|
108
|
+
f"pixel array shape {self.pixel_array.shape} does not match "
|
|
109
|
+
f"header dimensions {expected_shape} "
|
|
110
|
+
"(tof, bin, view, axial)"
|
|
111
|
+
)
|
|
112
|
+
|
|
100
113
|
def _write(base_path: Path, cleanup: bool) -> AcquisitionData:
|
|
101
114
|
header_path = base_path.with_suffix(".hs")
|
|
102
115
|
raw_file_path = base_path.with_suffix(".s")
|
|
@@ -112,9 +125,8 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
112
125
|
|
|
113
126
|
acqdata = self._load_acquisition(str(header_path))
|
|
114
127
|
|
|
115
|
-
flipped = np.flip(self.pixel_array, axis=-1)
|
|
116
128
|
acqdata = acqdata.clone()
|
|
117
|
-
acqdata.fill(
|
|
129
|
+
acqdata.fill(self.pixel_array)
|
|
118
130
|
acqdata.write(str(header_path))
|
|
119
131
|
|
|
120
132
|
if cleanup:
|
|
@@ -194,27 +206,50 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
194
206
|
acqdata = self.build(output_path=output_path_base)
|
|
195
207
|
return [acqdata]
|
|
196
208
|
|
|
209
|
+
if self.pixel_array is None:
|
|
210
|
+
raise ValueError(
|
|
211
|
+
"build_multi_energy requires pixel_array to be set "
|
|
212
|
+
"(use update_header_from_dicom or set it directly)"
|
|
213
|
+
)
|
|
214
|
+
|
|
215
|
+
num_windows = len(self.energy_windows)
|
|
216
|
+
total_projections = int(self.header.get("!number of projections", 1))
|
|
217
|
+
if self.pixel_array.ndim != 4 or (
|
|
218
|
+
self.pixel_array.shape[2] != total_projections
|
|
219
|
+
):
|
|
220
|
+
raise ValueError(
|
|
221
|
+
f"pixel array shape {self.pixel_array.shape} does not match "
|
|
222
|
+
f"declared {total_projections} projections"
|
|
223
|
+
)
|
|
224
|
+
if total_projections % num_windows != 0:
|
|
225
|
+
raise ValueError(
|
|
226
|
+
f"Number of projections ({total_projections}) must be divisible "
|
|
227
|
+
f"by the number of energy windows ({num_windows})"
|
|
228
|
+
)
|
|
229
|
+
projections_per_window = total_projections // num_windows
|
|
230
|
+
|
|
197
231
|
# number of projections needs dividing by number of energy windows
|
|
198
|
-
|
|
199
|
-
num_projections //= len(self.energy_windows)
|
|
200
|
-
self.header["!number of projections"] = str(num_projections)
|
|
232
|
+
self.header["!number of projections"] = str(projections_per_window)
|
|
201
233
|
|
|
202
234
|
# split pixel_array into energy windows along 3rd axis
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
235
|
+
original_pixel_array = self.pixel_array
|
|
236
|
+
try:
|
|
237
|
+
pixel_array_list = np.array_split(original_pixel_array, num_windows, axis=2)
|
|
238
|
+
|
|
239
|
+
acqdata_list = []
|
|
240
|
+
for idx, ew in enumerate(self.energy_windows):
|
|
241
|
+
# Update header for this energy window.
|
|
242
|
+
self.header["energy window lower level[1]"] = ew["lower"]
|
|
243
|
+
self.header["energy window upper level[1]"] = ew["upper"]
|
|
244
|
+
suffix = f"_ew{idx + 1}"
|
|
245
|
+
output_path = output_path_base + suffix
|
|
246
|
+
self.pixel_array = pixel_array_list[idx]
|
|
247
|
+
acqdata = self.build(output_path=output_path)
|
|
248
|
+
acqdata_list.append(acqdata)
|
|
249
|
+
return acqdata_list
|
|
250
|
+
finally:
|
|
251
|
+
self.pixel_array = original_pixel_array
|
|
252
|
+
self.header["!number of projections"] = str(total_projections)
|
|
218
253
|
|
|
219
254
|
def update_header_from_dicom(self, dicom_filepath):
|
|
220
255
|
"""
|
|
@@ -303,6 +338,8 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
303
338
|
)
|
|
304
339
|
|
|
305
340
|
# Rotation Information Sequence processing
|
|
341
|
+
num_frames = ds.get("NumberOfFrames", None)
|
|
342
|
+
time_per_projection = None
|
|
306
343
|
try:
|
|
307
344
|
if (0x0054, 0x0052) in ds:
|
|
308
345
|
rot_seq = ds[(0x0054, 0x0052)].value
|
|
@@ -322,16 +359,17 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
322
359
|
rot_item[(0x0018, 0x1242)].value / 1000
|
|
323
360
|
)
|
|
324
361
|
|
|
325
|
-
if num_frames is not None:
|
|
362
|
+
if time_per_projection is not None and num_frames is not None:
|
|
326
363
|
self.header["number of time frames"] = str(1)
|
|
327
364
|
self.header["!image duration (sec)[1]"] = str(
|
|
328
365
|
int(
|
|
329
366
|
np.round(
|
|
330
|
-
float(time_per_projection) * float(num_frames),
|
|
367
|
+
float(time_per_projection) * float(num_frames),
|
|
368
|
+
0,
|
|
331
369
|
)
|
|
332
370
|
)
|
|
333
371
|
)
|
|
334
|
-
|
|
372
|
+
elif time_per_projection is not None:
|
|
335
373
|
self.header["!time per projection (sec)[1]"] = (
|
|
336
374
|
time_per_projection
|
|
337
375
|
)
|
|
@@ -516,11 +554,21 @@ class STIRSPECTAcquisitionDataBuilder:
|
|
|
516
554
|
except AttributeError:
|
|
517
555
|
warnings.warn("StudyDescription not found in DICOM.")
|
|
518
556
|
try:
|
|
519
|
-
|
|
520
|
-
print(self.pixel_array.shape)
|
|
521
|
-
self.pixel_array = np.transpose(self.pixel_array, (2, 0, 1))
|
|
522
|
-
# rotate the image by 90 degrees cW in axis 1
|
|
523
|
-
self.pixel_array = np.rot90(self.pixel_array, 3, axes=(0, 2))
|
|
524
|
-
self.pixel_array = np.expand_dims(self.pixel_array, axis=0)
|
|
557
|
+
raw_pixel_array = ds.pixel_array
|
|
525
558
|
except AttributeError:
|
|
526
559
|
warnings.warn("Pixel data not found in DICOM.")
|
|
560
|
+
return
|
|
561
|
+
|
|
562
|
+
raw_pixel_array = np.asarray(raw_pixel_array)
|
|
563
|
+
if raw_pixel_array.ndim == 2:
|
|
564
|
+
# Single frame: promote to (frames=1, rows, columns) so the
|
|
565
|
+
# transpose below sees the same layout as multiframe data.
|
|
566
|
+
raw_pixel_array = raw_pixel_array[np.newaxis, :, :]
|
|
567
|
+
elif raw_pixel_array.ndim != 3:
|
|
568
|
+
raise ValueError(
|
|
569
|
+
f"pixel data must be 2D or 3D, got {raw_pixel_array.ndim}D"
|
|
570
|
+
)
|
|
571
|
+
self.pixel_array = np.transpose(raw_pixel_array, (2, 0, 1))
|
|
572
|
+
# rotate the image by 90 degrees cW in axis 1
|
|
573
|
+
self.pixel_array = np.rot90(self.pixel_array, 3, axes=(0, 2))
|
|
574
|
+
self.pixel_array = np.expand_dims(self.pixel_array, axis=0)
|
|
@@ -79,12 +79,24 @@ class STIRSPECTImageDataBuilder:
|
|
|
79
79
|
|
|
80
80
|
def _resolve_data_array(self) -> np.ndarray:
|
|
81
81
|
if self.pixel_array is not None:
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
82
|
+
data = np.asarray(self.pixel_array, dtype=np.float32)
|
|
83
|
+
else:
|
|
84
|
+
dim_x = int(self.header["!matrix size [1]"])
|
|
85
|
+
dim_y = int(self.header["!matrix size [2]"])
|
|
86
|
+
dim_z = int(self.header["!matrix size [3]"])
|
|
87
|
+
data = np.zeros((dim_z, dim_y, dim_x), dtype=np.float32)
|
|
88
|
+
|
|
89
|
+
expected_shape = (
|
|
90
|
+
int(self.header["!matrix size [3]"]),
|
|
91
|
+
int(self.header["!matrix size [2]"]),
|
|
92
|
+
int(self.header["!matrix size [1]"]),
|
|
93
|
+
)
|
|
94
|
+
if data.shape != expected_shape:
|
|
95
|
+
raise ValueError(
|
|
96
|
+
f"pixel array shape {data.shape} does not match header "
|
|
97
|
+
f"dimensions {expected_shape} (z, y, x)"
|
|
98
|
+
)
|
|
99
|
+
return data
|
|
88
100
|
|
|
89
101
|
def build(self, output_path: Optional[str | Path] = None):
|
|
90
102
|
"""
|
|
@@ -1,4 +1,10 @@
|
|
|
1
|
-
"""Connector/adaptor APIs.
|
|
1
|
+
"""Connector/adaptor APIs.
|
|
2
|
+
|
|
3
|
+
Backend-specific adaptors are exposed lazily so that importing this package
|
|
4
|
+
never imports SIRF, STIR, or PyTomography.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
import importlib
|
|
2
8
|
|
|
3
9
|
from .base import BaseConnector
|
|
4
10
|
from .python_connector import (
|
|
@@ -7,9 +13,22 @@ from .python_connector import (
|
|
|
7
13
|
RuntimeOperator,
|
|
8
14
|
SimindPythonConnector,
|
|
9
15
|
)
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
_LAZY_ADAPTORS = {
|
|
19
|
+
"PyTomographySimindAdaptor": "pytomography_adaptor",
|
|
20
|
+
"SirfSimindAdaptor": "sirf_adaptor",
|
|
21
|
+
"StirSimindAdaptor": "stir_adaptor",
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def __getattr__(name):
|
|
26
|
+
if name in _LAZY_ADAPTORS:
|
|
27
|
+
module = importlib.import_module(f".{_LAZY_ADAPTORS[name]}", __name__)
|
|
28
|
+
obj = getattr(module, name)
|
|
29
|
+
globals()[name] = obj
|
|
30
|
+
return obj
|
|
31
|
+
raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
|
|
13
32
|
|
|
14
33
|
|
|
15
34
|
__all__ = [
|
|
@@ -17,9 +17,11 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
|
|
|
17
17
|
|
|
18
18
|
if values:
|
|
19
19
|
if len(values) >= 4:
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
20
|
+
# Raw STIR-style coordinate sequence: (unused, z, y, x)
|
|
21
|
+
return float(values[1])
|
|
22
|
+
if len(values) == 3:
|
|
23
|
+
# Public (z, y, x) convention
|
|
24
|
+
return float(values[0])
|
|
23
25
|
|
|
24
26
|
if hasattr(spacing, "z"):
|
|
25
27
|
try:
|
|
@@ -28,13 +30,13 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
|
|
|
28
30
|
pass
|
|
29
31
|
|
|
30
32
|
if hasattr(spacing, "at"):
|
|
31
|
-
for index in (
|
|
33
|
+
for index in (1, 2, 3):
|
|
32
34
|
try:
|
|
33
35
|
return float(spacing.at(index))
|
|
34
36
|
except Exception:
|
|
35
37
|
continue
|
|
36
38
|
|
|
37
|
-
for index in (
|
|
39
|
+
for index in (1, 2, 3):
|
|
38
40
|
try:
|
|
39
41
|
return float(spacing[index])
|
|
40
42
|
except Exception:
|
|
@@ -44,12 +46,16 @@ def _voxel_size_from_spacing(spacing: Any) -> float | None:
|
|
|
44
46
|
|
|
45
47
|
|
|
46
48
|
def extract_voxel_size_mm(image: Any, backend_name: str) -> float:
|
|
47
|
-
"""Extract z voxel spacing in mm from backend image metadata.
|
|
49
|
+
"""Extract z voxel spacing in mm from backend image metadata.
|
|
50
|
+
|
|
51
|
+
Backend images report ``voxel_sizes()`` in ``(z, y, x)`` order, so the
|
|
52
|
+
first element is the z spacing.
|
|
53
|
+
"""
|
|
48
54
|
if hasattr(image, "voxel_sizes"):
|
|
49
55
|
voxel_sizes = image.voxel_sizes()
|
|
50
56
|
try:
|
|
51
57
|
if len(voxel_sizes) >= 3:
|
|
52
|
-
return float(voxel_sizes[
|
|
58
|
+
return float(voxel_sizes[0])
|
|
53
59
|
except Exception:
|
|
54
60
|
pass
|
|
55
61
|
|
|
@@ -6,6 +6,7 @@ from __future__ import annotations
|
|
|
6
6
|
|
|
7
7
|
import contextlib
|
|
8
8
|
import logging
|
|
9
|
+
import math
|
|
9
10
|
import os
|
|
10
11
|
import shutil
|
|
11
12
|
from dataclasses import dataclass, field
|
|
@@ -62,11 +63,12 @@ class SimindPythonConnector(BaseConnector):
|
|
|
62
63
|
quantization_scale: float = 1.0,
|
|
63
64
|
) -> None:
|
|
64
65
|
self.logger = logging.getLogger(__name__)
|
|
66
|
+
self._validate_output_prefix(output_prefix)
|
|
65
67
|
self.output_dir = Path(output_dir).expanduser().resolve()
|
|
66
68
|
self.output_dir.mkdir(parents=True, exist_ok=True)
|
|
67
69
|
self.output_prefix = output_prefix
|
|
68
70
|
self.quantization_scale = float(quantization_scale)
|
|
69
|
-
if self.quantization_scale <= 0:
|
|
71
|
+
if not math.isfinite(self.quantization_scale) or self.quantization_scale <= 0:
|
|
70
72
|
raise ValueError("quantization_scale must be > 0")
|
|
71
73
|
|
|
72
74
|
self.config = self._initialize_config(config_source)
|
|
@@ -75,12 +77,32 @@ class SimindPythonConnector(BaseConnector):
|
|
|
75
77
|
self.converter = SimindToStirConverter()
|
|
76
78
|
|
|
77
79
|
self._outputs: Optional[dict[str, ProjectionResult]] = None
|
|
80
|
+
self._window_file_path: Optional[Path] = None
|
|
81
|
+
self._phantom_extent_mm: Optional[tuple[float, float]] = None
|
|
82
|
+
|
|
83
|
+
@staticmethod
|
|
84
|
+
def _validate_output_prefix(prefix: str) -> None:
|
|
85
|
+
"""Reject prefixes that could escape the output directory."""
|
|
86
|
+
if (
|
|
87
|
+
not isinstance(prefix, str)
|
|
88
|
+
or not prefix
|
|
89
|
+
or prefix in {".", ".."}
|
|
90
|
+
or "/" in prefix
|
|
91
|
+
or "\\" in prefix
|
|
92
|
+
or Path(prefix).is_absolute()
|
|
93
|
+
):
|
|
94
|
+
raise ValueError(f"output_prefix must be a plain filename, got {prefix!r}")
|
|
78
95
|
|
|
79
96
|
@staticmethod
|
|
80
97
|
def _initialize_config(config_source: ConfigSource) -> SimulationConfig:
|
|
81
98
|
if isinstance(config_source, SimulationConfig):
|
|
82
99
|
return config_source
|
|
83
100
|
|
|
101
|
+
if not isinstance(config_source, (str, os.PathLike)):
|
|
102
|
+
# importlib.resources Traversable from configs.get(): hand it to
|
|
103
|
+
# SimulationConfig untouched (supports zipped installs).
|
|
104
|
+
return SimulationConfig(config_source)
|
|
105
|
+
|
|
84
106
|
config_path = Path(config_source).expanduser().resolve()
|
|
85
107
|
if not config_path.exists():
|
|
86
108
|
raise FileNotFoundError(f"Configuration file not found: {config_source}")
|
|
@@ -107,11 +129,15 @@ class SimindPythonConnector(BaseConnector):
|
|
|
107
129
|
source: np.ndarray,
|
|
108
130
|
mu_map: np.ndarray,
|
|
109
131
|
voxel_size_mm: float = 4.0,
|
|
110
|
-
scoring_routine: Union[ScoringRoutine, int] =
|
|
132
|
+
scoring_routine: Optional[Union[ScoringRoutine, int]] = None,
|
|
111
133
|
) -> tuple[Path, Path]:
|
|
112
134
|
"""
|
|
113
135
|
Configure voxel geometry and write source/density input files.
|
|
114
136
|
|
|
137
|
+
The projection pixel size and matrix (Index 28, 76, 77) come from the
|
|
138
|
+
configuration, not from the phantom. scoring_routine overrides Index 84;
|
|
139
|
+
None keeps the configuration value.
|
|
140
|
+
|
|
115
141
|
Returns:
|
|
116
142
|
Tuple of (source_file_path, density_file_path).
|
|
117
143
|
"""
|
|
@@ -124,14 +150,32 @@ class SimindPythonConnector(BaseConnector):
|
|
|
124
150
|
raise ValueError("source and mu_map must have identical shapes")
|
|
125
151
|
|
|
126
152
|
vox_cm = float(voxel_size_mm) / SIMIND_VOXEL_UNIT_CONVERSION
|
|
127
|
-
if vox_cm <= 0:
|
|
153
|
+
if not math.isfinite(vox_cm) or vox_cm <= 0:
|
|
128
154
|
raise ValueError("voxel_size_mm must be > 0")
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
155
|
+
if source_array.size == 0 or mu_map_array.size == 0:
|
|
156
|
+
raise ValueError("source and mu_map must not be empty")
|
|
157
|
+
if not np.isfinite(source_array).all() or not np.isfinite(mu_map_array).all():
|
|
158
|
+
raise ValueError("source and mu_map must contain only finite values")
|
|
159
|
+
if (source_array < 0).any() or (mu_map_array < 0).any():
|
|
160
|
+
raise ValueError("source and mu_map must be non-negative")
|
|
161
|
+
|
|
162
|
+
if scoring_routine is None:
|
|
163
|
+
routine = None
|
|
164
|
+
elif isinstance(scoring_routine, ScoringRoutine):
|
|
165
|
+
routine = scoring_routine
|
|
166
|
+
elif isinstance(scoring_routine, int) and not isinstance(scoring_routine, bool):
|
|
167
|
+
try:
|
|
168
|
+
routine = ScoringRoutine(scoring_routine)
|
|
169
|
+
except ValueError as exc:
|
|
170
|
+
raise ValueError(
|
|
171
|
+
f"scoring_routine {scoring_routine!r} is not a valid "
|
|
172
|
+
"ScoringRoutine value"
|
|
173
|
+
) from exc
|
|
174
|
+
else:
|
|
175
|
+
raise ValueError(
|
|
176
|
+
"scoring_routine must be None, a ScoringRoutine or int, got "
|
|
177
|
+
f"{type(scoring_routine).__name__}"
|
|
178
|
+
)
|
|
135
179
|
dim_z, dim_y, dim_x = (int(v) for v in source_array.shape)
|
|
136
180
|
|
|
137
181
|
cfg = self.config
|
|
@@ -139,15 +183,13 @@ class SimindPythonConnector(BaseConnector):
|
|
|
139
183
|
cfg.set_value(15, -1)
|
|
140
184
|
cfg.set_value(14, -1)
|
|
141
185
|
cfg.set_flag(14, True)
|
|
142
|
-
|
|
186
|
+
if routine is not None:
|
|
187
|
+
cfg.set_value(84, routine.value)
|
|
143
188
|
|
|
144
189
|
# Source geometry
|
|
145
190
|
cfg.set_value(2, dim_z * vox_cm / 2.0)
|
|
146
191
|
cfg.set_value(3, dim_x * vox_cm / 2.0)
|
|
147
192
|
cfg.set_value(4, dim_y * vox_cm / 2.0)
|
|
148
|
-
cfg.set_value(28, vox_cm)
|
|
149
|
-
cfg.set_value(76, dim_x)
|
|
150
|
-
cfg.set_value(77, dim_y)
|
|
151
193
|
|
|
152
194
|
# Density geometry
|
|
153
195
|
cfg.set_value(5, dim_z * vox_cm / 2.0)
|
|
@@ -156,10 +198,14 @@ class SimindPythonConnector(BaseConnector):
|
|
|
156
198
|
cfg.set_value(31, vox_cm)
|
|
157
199
|
cfg.set_value(33, 1)
|
|
158
200
|
cfg.set_value(34, dim_z)
|
|
159
|
-
cfg.set_value(78, dim_x)
|
|
160
|
-
cfg.set_value(79,
|
|
201
|
+
cfg.set_value(78, dim_x) # density map i
|
|
202
|
+
cfg.set_value(79, dim_x) # source map i
|
|
203
|
+
cfg.set_value(81, dim_y) # density map j
|
|
204
|
+
cfg.set_value(82, dim_y) # source map j
|
|
161
205
|
|
|
162
206
|
self.runtime_switches.set_switch("PX", vox_cm)
|
|
207
|
+
voxel_mm = float(voxel_size_mm)
|
|
208
|
+
self._phantom_extent_mm = (max(dim_x, dim_y) * voxel_mm, dim_z * voxel_mm)
|
|
163
209
|
|
|
164
210
|
source_max = float(source_array.max())
|
|
165
211
|
if source_max > 0:
|
|
@@ -198,12 +244,14 @@ class SimindPythonConnector(BaseConnector):
|
|
|
198
244
|
scatter_orders: Union[int, list[int]],
|
|
199
245
|
) -> None:
|
|
200
246
|
"""Write a SIMIND window file for this connector run."""
|
|
247
|
+
window_path = self.output_dir / f"{self.output_prefix}.win"
|
|
201
248
|
create_window_file(
|
|
202
249
|
lower_bounds,
|
|
203
250
|
upper_bounds,
|
|
204
251
|
scatter_orders,
|
|
205
|
-
output_filename=str(
|
|
252
|
+
output_filename=str(window_path),
|
|
206
253
|
)
|
|
254
|
+
self._window_file_path = window_path
|
|
207
255
|
|
|
208
256
|
def run(
|
|
209
257
|
self, runtime_operator: Optional[RuntimeOperator] = None
|
|
@@ -211,22 +259,47 @@ class SimindPythonConnector(BaseConnector):
|
|
|
211
259
|
"""Run SIMIND and return projection outputs as NumPy arrays."""
|
|
212
260
|
self._outputs = None
|
|
213
261
|
|
|
262
|
+
# Runtime-operator switches apply to this run only; merge them into
|
|
263
|
+
# a throwaway switch set instead of persistent connector state.
|
|
264
|
+
run_switches_holder = RuntimeSwitches()
|
|
265
|
+
for key, value in self.runtime_switches.switches.items():
|
|
266
|
+
run_switches_holder.set_switch(key, value)
|
|
214
267
|
orbit_file = None
|
|
215
268
|
if runtime_operator is not None:
|
|
216
|
-
|
|
269
|
+
for key, value in runtime_operator.switches.items():
|
|
270
|
+
run_switches_holder.set_switch(key, value)
|
|
217
271
|
orbit_file = self._prepare_orbit_file(runtime_operator.orbit_file)
|
|
218
272
|
|
|
273
|
+
if self._phantom_extent_mm is not None:
|
|
274
|
+
bin_mm = float(self.config.get_value(28)) * SIMIND_VOXEL_UNIT_CONVERSION
|
|
275
|
+
width_mm, length_mm = self._phantom_extent_mm
|
|
276
|
+
fov_width_mm = float(self.config.get_value(76)) * bin_mm
|
|
277
|
+
fov_length_mm = float(self.config.get_value(77)) * bin_mm
|
|
278
|
+
if width_mm > fov_width_mm:
|
|
279
|
+
self.logger.warning(
|
|
280
|
+
"The phantom (%.1f mm across) is wider than the projection "
|
|
281
|
+
"field of view (%.1f mm)",
|
|
282
|
+
width_mm,
|
|
283
|
+
fov_width_mm,
|
|
284
|
+
)
|
|
285
|
+
if length_mm > fov_length_mm:
|
|
286
|
+
self.logger.warning(
|
|
287
|
+
"The phantom (%.1f mm axially) is longer than the projection "
|
|
288
|
+
"field of view (%.1f mm)",
|
|
289
|
+
length_mm,
|
|
290
|
+
fov_length_mm,
|
|
291
|
+
)
|
|
292
|
+
|
|
219
293
|
config_path = self.output_dir / self.output_prefix
|
|
220
294
|
self.config.save_file(config_path)
|
|
221
295
|
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
os.chdir(original_cwd)
|
|
296
|
+
self._clear_previous_outputs()
|
|
297
|
+
self.executor.run_simulation(
|
|
298
|
+
self.output_prefix,
|
|
299
|
+
orbit_file,
|
|
300
|
+
run_switches_holder.switches,
|
|
301
|
+
cwd=self.output_dir,
|
|
302
|
+
)
|
|
230
303
|
|
|
231
304
|
header_files = self._ensure_interfile_headers()
|
|
232
305
|
self._outputs = self._load_projection_outputs(header_files)
|
|
@@ -241,6 +314,46 @@ class SimindPythonConnector(BaseConnector):
|
|
|
241
314
|
def get_config(self) -> SimulationConfig:
|
|
242
315
|
return self.config
|
|
243
316
|
|
|
317
|
+
_OUTPUT_SUFFIXES = {".h00", ".hs", ".a00", ".s", ".win"}
|
|
318
|
+
|
|
319
|
+
def _clear_previous_outputs(self) -> None:
|
|
320
|
+
"""Delete stale outputs from earlier runs sharing this prefix.
|
|
321
|
+
|
|
322
|
+
Connector-written inputs (``{prefix}_src.smi`` / ``{prefix}_dns.dmi``)
|
|
323
|
+
are protected because SIMIND still needs them on disk.
|
|
324
|
+
"""
|
|
325
|
+
protected = {
|
|
326
|
+
f"{self.output_prefix}_src.smi",
|
|
327
|
+
f"{self.output_prefix}_dns.dmi",
|
|
328
|
+
}
|
|
329
|
+
if (
|
|
330
|
+
self._window_file_path is not None
|
|
331
|
+
and self._window_file_path.parent == self.output_dir
|
|
332
|
+
):
|
|
333
|
+
# Energy-window input written via set_energy_windows(); protect
|
|
334
|
+
# only that exact file, never a pre-existing one at the current
|
|
335
|
+
# prefix/location.
|
|
336
|
+
protected.add(self._window_file_path.name)
|
|
337
|
+
for slot in (5, 6):
|
|
338
|
+
try:
|
|
339
|
+
protected.add(self.config.get_data_file(slot))
|
|
340
|
+
except KeyError:
|
|
341
|
+
pass
|
|
342
|
+
for path in sorted(self.output_dir.iterdir()):
|
|
343
|
+
if not path.is_file() or path.name in protected:
|
|
344
|
+
continue
|
|
345
|
+
stem_ok = path.stem == self.output_prefix or path.stem.startswith(
|
|
346
|
+
f"{self.output_prefix}_"
|
|
347
|
+
)
|
|
348
|
+
if not stem_ok:
|
|
349
|
+
continue
|
|
350
|
+
if path.suffix in self._OUTPUT_SUFFIXES or (
|
|
351
|
+
path.suffix.startswith(".b")
|
|
352
|
+
and path.suffix[2:].isdigit()
|
|
353
|
+
and path.stem == self.output_prefix
|
|
354
|
+
):
|
|
355
|
+
path.unlink()
|
|
356
|
+
|
|
244
357
|
def _prepare_orbit_file(self, orbit_file: Optional[PathLike]) -> Optional[Path]:
|
|
245
358
|
if orbit_file is None:
|
|
246
359
|
return None
|
|
@@ -273,12 +386,18 @@ class SimindPythonConnector(BaseConnector):
|
|
|
273
386
|
self.output_dir.glob(f"{self.output_prefix}_component_*.hs")
|
|
274
387
|
)
|
|
275
388
|
else:
|
|
276
|
-
h00_files = sorted(
|
|
389
|
+
h00_files = sorted(
|
|
390
|
+
set(self.output_dir.glob(f"{self.output_prefix}_*.h00"))
|
|
391
|
+
| set(self.output_dir.glob(f"{self.output_prefix}.h00"))
|
|
392
|
+
)
|
|
277
393
|
for h00_file in h00_files:
|
|
278
394
|
hs_file = h00_file.with_suffix(".hs")
|
|
279
395
|
self.converter.convert_file(str(h00_file), str(hs_file))
|
|
280
396
|
|
|
281
|
-
hs_files = sorted(
|
|
397
|
+
hs_files = sorted(
|
|
398
|
+
set(self.output_dir.glob(f"{self.output_prefix}_*.hs"))
|
|
399
|
+
| {h00_file.with_suffix(".hs") for h00_file in h00_files}
|
|
400
|
+
)
|
|
282
401
|
if not hs_files:
|
|
283
402
|
raise FileNotFoundError(
|
|
284
403
|
f"No projection headers (.hs) found for prefix {self.output_prefix!r} "
|
|
@@ -134,6 +134,11 @@ class PyTomographySimindAdaptor(BaseConnector):
|
|
|
134
134
|
def run(
|
|
135
135
|
self, runtime_operator: Optional[RuntimeOperator] = None
|
|
136
136
|
) -> Dict[str, torch.Tensor]:
|
|
137
|
+
# Clear all output caches up front so failed reruns cannot leak
|
|
138
|
+
# results from a previous successful run.
|
|
139
|
+
self._outputs = None
|
|
140
|
+
self._output_metadata = None
|
|
141
|
+
self._output_header_paths = None
|
|
137
142
|
self._validate_inputs()
|
|
138
143
|
assert self._source is not None # for type checkers
|
|
139
144
|
assert self._mu_map is not None
|
|
@@ -79,6 +79,9 @@ class SirfSimindAdaptor(BaseConnector):
|
|
|
79
79
|
self.python_connector.add_runtime_switch(switch, value)
|
|
80
80
|
|
|
81
81
|
def run(self, runtime_operator: Optional[RuntimeOperator] = None) -> dict[str, Any]:
|
|
82
|
+
# Drop cached outputs before validation so a failed rerun can never
|
|
83
|
+
# expose results from a previous successful run.
|
|
84
|
+
self._outputs = None
|
|
82
85
|
self._validate_inputs()
|
|
83
86
|
assert self._source is not None
|
|
84
87
|
assert self._mu_map is not None
|
|
@@ -79,6 +79,9 @@ class StirSimindAdaptor(BaseConnector):
|
|
|
79
79
|
self.python_connector.add_runtime_switch(switch, value)
|
|
80
80
|
|
|
81
81
|
def run(self, runtime_operator: Optional[RuntimeOperator] = None) -> dict[str, Any]:
|
|
82
|
+
# Drop cached outputs before validation so a failed rerun can never
|
|
83
|
+
# expose results from a previous successful run.
|
|
84
|
+
self._outputs = None
|
|
82
85
|
self._validate_inputs()
|
|
83
86
|
assert self._source is not None
|
|
84
87
|
assert self._mu_map is not None
|
|
@@ -57,7 +57,9 @@ def get_attenuation_coefficient(material, energy, file_path=None):
|
|
|
57
57
|
raise ValueError("Unknown material. Accepted values are 'water' or 'bone'.")
|
|
58
58
|
|
|
59
59
|
if file_path:
|
|
60
|
-
|
|
60
|
+
# filename may already be an absolute packaged path; join only its
|
|
61
|
+
# basename so the override directory is honoured.
|
|
62
|
+
filepath = Path(file_path) / Path(str(filename)).name
|
|
61
63
|
else:
|
|
62
64
|
filepath = get_package_data_path(filename)
|
|
63
65
|
|