| # Dose conversion tools |
|
|
| `convert_dose_images.py` converts the published total-dose images of the DosePET dataset into: |
|
|
| - **dose-rate maps**, in mGy/h (or mGy/s, Gy/s), at scan start by default, and |
| - **dose conversion factor maps**, in **Gy per decay**, |
|
|
| and can reproduce the shipped per-organ tables from the images and masks so you |
| can verify the release yourself. |
|
|
| --- |
|
|
| ## 1. The one thing to know |
|
|
| Each voxel of `dose_image.nii.gz` is the **total absorbed dose in Gy**, |
| integrated from the start of the scan to infinity assuming **physical decay |
| only** (the activity distribution is frozen in space; no biological clearance, |
| no redistribution). |
|
|
| Because the only time dependence is a single exponential shared by every voxel, |
| both conversions are a multiplication of the whole image by **one scalar**: |
|
|
| | quantity | formula | units | |
| |---|---|---| |
| | dose rate at scan start | `Ddot = D * ln2 / T_half` | Gy/s | |
| | dose rate at scan start | `Ddot = D * 3.6e6 * ln2 / T_half` | mGy/h | |
| | dose conversion factor | `DCF = D / A_tilde` | Gy per decay | |
|
|
| where `T_half` is the isotope half-life of that case and `A_tilde` is that |
| case's cumulated activity in Bq·s (1 Bq·s = 1 decay). Both are recorded per |
| case inside the dataset — the script finds them for you. |
|
|
| Two optional time shifts follow from the same relation: |
|
|
| ``` |
| Ddot(tau) = Ddot(0) * exp(-lambda*tau) tau seconds after the scan |
| Ddot(t_inj) = Ddot(0) * ICF back to injection time |
| lambda = ln2 / T_half |
| ``` |
|
|
| Full derivation and the assumptions to cite: see `../dose_conversion_plan.md`. |
|
|
| --- |
|
|
| ## 2. Requirements |
|
|
| ```bash |
| pip install numpy nibabel SimpleITK |
| ``` |
|
|
| `nibabel` is needed for the image modes, `SimpleITK` for the mask-based modes |
| (`organs`, `check`). Python 3.8+. |
|
|
| --- |
|
|
| ## 3. Quick start |
|
|
| Set a shell variable for the dataset so the examples stay short: |
|
|
| ```bash |
| DATA="/media/et/Seagate Basic/PET_CT_Dose_Data/dataset_ready_for_publication" |
| ``` |
|
|
| ### 3.1 Dose-rate maps in mGy/h (the common case) |
|
|
| ```bash |
| python3 convert_dose_images.py rate \ |
| --root "$DATA/FDG" \ |
| --out ~/dose_rate_FDG |
| ``` |
|
|
| Every case gets `dose_rate_at_scan_mGy_per_h.nii.gz` plus a `.json` sidecar |
| recording the scale factor, half-life, cumulated activity, and the source path. |
|
|
| Try it on a couple of cases first: |
|
|
| ```bash |
| python3 convert_dose_images.py rate --root "$DATA/FDG" --out ~/trial --limit 2 --verify |
| ``` |
|
|
| `--verify` reloads each output and confirms its maximum equals |
| `max(dose) x k`. |
|
|
| ### 3.2 Other units |
|
|
| ```bash |
| python3 convert_dose_images.py rate --root "$DATA/PSMA" --out ~/rate_s --unit mGy_per_s |
| python3 convert_dose_images.py rate --root "$DATA/PSMA" --out ~/rate_gys --unit Gy_per_s |
| ``` |
|
|
| Choices: `mGy_per_h` (default), `mGy_per_min`, `mGy_per_s`, `Gy_per_s`. |
|
|
| ### 3.3 A different time point (opt-in) |
|
|
| The default is always **scan start**. To ask for something else: |
|
|
| ```bash |
| # dose rate one hour after the start of the scan |
| python3 convert_dose_images.py rate --root "$DATA/FDG" --out ~/rate_1h --at +3600 |
| |
| # dose rate back-extrapolated to injection time |
| python3 convert_dose_images.py rate --root "$DATA/FDG" --out ~/rate_inj --at injection |
| ``` |
|
|
| `--at injection` uses the stored `injection_correction_factor`. Four FDG cases |
| (`0718`, `1022`, `1195`, `1289`) do not have one, because the acquisition time |
| is missing in the source metadata; they are skipped with an explicit message |
| and everything else proceeds: |
|
|
| ``` |
| [1/1] SKIP 0718: injection_correction_factor unavailable (acquisition time missing in the source metadata) |
| ``` |
|
|
| ### 3.4 Dose conversion factor maps, Gy per decay |
|
|
| ```bash |
| python3 convert_dose_images.py dcf --root "$DATA/PSMA" --out ~/dcf_PSMA |
| ``` |
|
|
| Produces `dose_conversion_factor_Gy_per_decay.nii.gz` per case. |
|
|
| > **Read this before using DCF.** `A_tilde` is the total cumulated activity in |
| > the **imaged field of view**. So a DCF voxel means *Gy delivered to that voxel |
| > per decay occurring anywhere in the FOV, with this patient's own tracer |
| > distribution as the source*. It is a FOV-normalised S-value. It is **not** |
| > dose per decay in a specific source organ, and must not be compared directly |
| > with organ-to-organ S-values from MIRD/OLINDA without that caveat. |
| |
| ### 3.5 Per-organ tables from the images and masks |
| |
| ```bash |
| # one case -> one CSV |
| python3 convert_dose_images.py organs \ |
| --case "$DATA/FDG/1597" \ |
| --out ~/organ_table_1597.csv |
| |
| # a whole subset -> one organ_table.csv per case, mirroring the dataset layout |
| python3 convert_dose_images.py organs --root "$DATA/PSMA" --out ~/organ_tables_PSMA |
| ``` |
| |
| The output uses **exactly the column names and order of the published |
| `dose_report.csv`**, alphabetical by organ, with the same line endings, so you |
| can diff the two directly: |
| |
| ```bash |
| diff <(cut -d, -f1 ~/organ_table_1597.csv) \ |
| <(cut -d, -f1 "$DATA/FDG/1597/dose_report.csv") # same organs, same order |
| ``` |
| |
| One column is written **empty**: `mass_g`, which needs the CT, and the CT is |
| not part of the release. |
|
|
| ### 3.6 Verify the release against the images |
|
|
| ```bash |
| python3 convert_dose_images.py check --root "$DATA/FDG" --json-out ~/check_FDG.json |
| ``` |
|
|
| `check` recomputes every reproducible column from `dose_image.nii.gz` + |
| `segmentation/*.nii.gz` and compares it against the shipped `dose_report.csv`, |
| printing an explicit PASS/FAIL per case: |
|
|
| ``` |
| [1/2] PASS 0001 117 organs, 1283 values, worst 0.499 x tolerance |
| [2/2] PASS 0002 117 organs, 1284 values, worst 0.496 x tolerance |
| |
| 2/2 cases PASS, 234 organ rows, 2567 values compared |
| ``` |
|
|
| "worst 0.499 x tolerance" is the largest deviation found, expressed as a |
| fraction of that column's own allowance (one quantisation step of the stored |
| uint16 dose image, carried through the column's scale factor). Anything below |
| 1.0 is agreement. `num_voxels` must match **exactly** and `volume_cm3` to 1e-9 |
| relative — those two catch a report row paired with the wrong mask. |
|
|
| To check a single case, point `--root` at that case directory: |
|
|
| ```bash |
| python3 convert_dose_images.py check --root "$DATA/FDG/0718" |
| ``` |
|
|
|
|
| --- |
|
|
| ## 4. Output modes, size and precision |
|
|
| ### `--mode header` (default, recommended) |
|
|
| The dose image is `uint16` with a `scl_slope` in the NIfTI header. Since the |
| conversion is a pure scalar, the script copies the integer payload **byte for |
| byte** and multiplies only `scl_slope`: |
|
|
| ``` |
| scl_slope_out = scl_slope_in * k |
| ``` |
|
|
| - **No second quantisation**: the output is exactly as precise as the source. |
| Verified: the uint16 payload of the output is bit-identical to the input's. |
| - The file stays the same size as the source. |
| - Residual error is only the float32 rounding of `scl_slope` itself, about |
| 1e-8 relative — three orders of magnitude below the 1.5e-5 relative |
| quantisation already present in the published image. |
|
|
| ### `--mode float32` |
|
|
| Decodes with the slope applied, multiplies, writes float32. Use this if your |
| software ignores `scl_slope`. Files are roughly 35% larger. |
|
|
| ### Disk space — please read |
|
|
| Converted maps are the same size as the originals, so converting a whole subset |
| **duplicates it** (hundreds of GB for FDG). Unless you genuinely need the files |
| on disk, apply the scalar on the fly instead: |
|
|
| ```python |
| import json, math, numpy as np, nibabel as nib |
| |
| case = "/path/to/dataset/FDG/1597" |
| cfg = json.load(open(f"{case}/dosimetry_config.json")) |
| meta = json.load(open(f"{case}/metadata.json")) |
| |
| T_half = cfg.get("half_life_seconds") or meta["isotope"]["half_life_seconds"] |
| A_tilde = cfg["cumulated_from_scan"] |
| |
| D = np.asanyarray(nib.load(f"{case}/dose_image.nii.gz").dataobj) # Gy |
| |
| rate_mGy_per_h = D * 3.6e6 * math.log(2) / T_half # at scan start |
| dcf_Gy_per_dec = D / A_tilde # Gy per decay |
| ``` |
|
|
| And if you only need **organ-level** numbers, you do not need to convert |
| anything at all: `dose_report.csv` already ships |
| `mean_dose_rate_at_scan_mGy_per_s`, `mean_dose_rate_at_scan_mGy_per_h` and |
| `dcf_Gy_per_Bqs`. |
|
|
| --- |
|
|
| ## 5. Where the constants come from |
|
|
| Per case, the script resolves the half-life in this order and records which one |
| it used in the sidecar JSON: |
|
|
| ``` |
| dosimetry_config.json : half_life_seconds |
| -> metadata.json : isotope.half_life_seconds |
| -> metadata.json : dicom_half_life_seconds |
| -> built-in isotope table (fallback, flagged) |
| ``` |
|
|
| Cumulated activity comes from `dosimetry_config.json : cumulated_from_scan`, |
| the same value used to scale the Monte Carlo output. |
|
|
|
|
| --- |
|
|
| ## 6. Output layout |
|
|
| ``` |
| <--out>/ |
| 0001/ |
| dose_rate_at_scan_mGy_per_h.nii.gz |
| dose_rate_at_scan_mGy_per_h.json |
| 0002/ |
| ... |
| ``` |
|
|
| For PSMA the nested `<patient>/<scan>/` structure is mirrored. Case discovery |
| is by searching for `dose_image.nii.gz` at any depth, so the flat FDG layout and |
| the nested PSMA layout both work with no extra flags. |
|
|
| Each sidecar JSON records the quantity, units, time point, the scale factor |
| applied, the formula, the decay-only assumption, the source path, every case |
| constant with its origin, and the resulting `scl_slope`. |
|
|
| --- |
|
|
| ## 7. Assumptions and caveats |
|
|
| 1. **Physical decay only.** No biological clearance, no redistribution. All rates and DCFs inherit this. |
| 2. **Time zero is scan start** — the integration window is `scan -> infinity` |
| in all cases. |
| 3. **`Gy per decay` is FOV-normalised**, not a source-organ S-value (§3.4). |
| 4. **Apply `scl_slope`.** The published images, and the header-mode outputs, are |
| uint16 with a scale factor in the header. nibabel and SimpleITK do this |
| automatically; some other toolkits do not. |
| 5. **Four FDG cases have no injection correction factor**: `0718`, `1022`, |
| `1195`, `1289`. Unaffected for scan-time rates and DCF; only `--at injection` |
| is unavailable for them. |
| |
| --- |
| |
| ## 8. Safety |
| |
| - `--out` is mandatory and the script exits if it resolves inside the dataset: |
| |
| ``` |
| REFUSING to write inside the dataset root. |
| ``` |
| - All dataset files are opened read-only. Nothing is written, renamed or |
| deleted inside the release. |
| - A case missing a required constant is skipped with a message, never silently |
| defaulted. |
| |
| --- |
| |
| ## 9. Command reference |
| |
| ``` |
| convert_dose_images.py rate --root DIR --out DIR [--unit U] [--at scan|injection|+N] |
| [--mode header|float32] [--verify] [--limit N] |
| |
| convert_dose_images.py dcf --root DIR --out DIR [--mode header|float32] |
| [--verify] [--limit N] |
| |
| convert_dose_images.py organs (--case DIR | --root DIR) --out PATH [--limit N] |
| |
| convert_dose_images.py check --root DIR [--json-out FILE] [--limit N] |
| ``` |
| |
| `python3 convert_dose_images.py <command> --help` prints the same detail. |
| |
