cmpl 0.2.2__tar.gz → 0.2.4__tar.gz

{cmpl-0.2.2/src/cmpl.egg-info → cmpl-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmpl
-Version: 0.2.2
+Version: 0.2.4
 Summary: CMRR MRI Processing Libraries
 Author: Eisa Hedayati
 License: Copyright (c) 2025 Eisa Hedayati
@@ -71,23 +71,32 @@ Dynamic: license-file
 
 # CMPL — CMRR MRI Processing Libraries
 
-[![PyPI](https://img.shields.io/pypi/v/cmpl.svg)](https://pypi.org/project/cmpl/)
-[![Python](https://img.shields.io/pypi/pyversions/cmpl.svg)](https://pypi.org/project/cmpl/)
+[![PyPI version](https://img.shields.io/pypi/v/cmpl.svg?cacheSeconds=300)](https://pypi.org/project/cmpl/)
+[![Python versions](https://img.shields.io/pypi/pyversions/cmpl.svg)](https://pypi.org/project/cmpl/)
 
-CMPL is a Python package for MRI processing workflows developed at CMRR. It provides tools for MRI reconstruction, quantitative MRI, visualization, DICOM/NIfTI I/O, and supporting numerical/data utilities.
+**PyPI:** https://pypi.org/project/cmpl/  
+**GitHub:** https://github.com/ehedayati/cmpl
 
-CMPL is organized as a modular library: the base installation stays lightweight, while larger or domain-specific dependencies are installed only when the corresponding functionality is needed.
+CMPL is a Python package for MRI processing workflows developed at CMRR. It provides tools for MRI reconstruction, quantitative MRI, visualization, DICOM/NIfTI conversion and I/O, and supporting numerical and data utilities.
+
+The package is modular by design: the base installation remains lightweight, while larger or domain-specific dependencies are installed only when the corresponding functionality is needed.
 
 ## Highlights
 
+- Geometry-aware conventional and Enhanced DICOM to NIfTI conversion
+- JSON metadata sidecars with acquisition and source-geometry information
+- Multi-echo DICOM support with 4D NIfTI output ordered by echo time
+- Packaged `cmpl-dicom-to-nifti` command-line converter
+- Packaged `cmpl-t2star` command-line T2* and S0 mapper
+- DICOM geometry and acquisition-metadata utilities
 - Parallel MRI reconstruction with 1D/2D GRAPPA and conjugate-gradient SENSE
 - Quantitative MRI tools for T2* fitting, signal reconstruction, and fitting-error analysis
-- MRI visualization utilities for 2D comparisons, 3D volume browsing, and segmentation overlays
-- DICOM, enhanced-DICOM, NIfTI, and SimpleITK utilities
+- MRI visualization utilities for 2D comparisons and 3D volume browsing
+- Conventional and Enhanced DICOM, NIfTI, HDF5, and SimpleITK utilities
 - Lightweight numerical utilities shared across CMPL
 - Optional pandas-based indexing for CMPL-style medical-data directory structures
-- Lazy package imports so `import cmpl` does not eagerly load large optional dependencies
-- Backward-compatible convenience aliases such as `cmpl.recon`, `cmpl.qmr`, `cmpl.vis`, and `cmpl.utils`
+- Lazy imports so unrelated optional dependencies are not loaded unnecessarily
+- Convenient aliases such as `cmpl.recon`, `cmpl.qmr`, `cmpl.vis`, and `cmpl.io`
 
 ## Requirements
 
@@ -98,7 +107,7 @@ CMPL requires:
 - SciPy >= 1.13, < 2
 - tqdm >= 4.66
 
-Additional dependencies are installed through optional extras.
+Additional functionality is provided through optional dependency groups.
 
 ## Installation
 
@@ -116,23 +125,29 @@ Install only the functionality you need:
 | `data` | pandas-based data indexing |
 | `viz` | Matplotlib and Jupyter visualization |
 | `torch` | PyTorch-based reconstruction and quantitative MRI |
-| `all` | All optional functionality declared by CMPL |
+| `all` | All optional CMPL functionality |
 | `dev` | Testing, linting, build, and release tools |
 
 Examples:
 
 ```bash
 python -m pip install "cmpl[io]"
-python -m pip install "cmpl[viz]"
 python -m pip install "cmpl[torch]"
-python -m pip install "cmpl[io,data,viz,torch]"
+python -m pip install "cmpl[viz]"
+python -m pip install "cmpl[io,torch]"
 python -m pip install "cmpl[all]"
 ```
 
-Quantitative-MRI fitting currently uses both PyTorch and Matplotlib, so for qMRI workflows install:
+For NIfTI-based T2* mapping:
 
 ```bash
-python -m pip install "cmpl[torch,viz]"
+python -m pip install "cmpl[io,torch]"
+```
+
+Matplotlib is only required when plotting is explicitly requested:
+
+```bash
+python -m pip install "cmpl[viz]"
 ```
 
 ## Quick start
@@ -149,109 +164,262 @@ CMPL exposes convenient aliases for commonly used subpackages:
 cmpl.recon   # reconstruction
 cmpl.qmr     # quantitative MRI
 cmpl.vis     # visualization
-cmpl.utils   # utilities
 cmpl.io      # I/O utilities
+cmpl.dicom   # DICOM metadata and geometry utilities
+cmpl.utils   # utilities
 ```
 
-The aliases are resolved lazily, so importing CMPL itself does not require every optional dependency to be loaded.
+These aliases are resolved lazily so `import cmpl` does not require every optional dependency to be installed or imported.
 
-## Visualization
+---
 
-Install the visualization extra:
+## DICOM and NIfTI I/O
+
+Install the I/O extra:
 
 ```bash
-python -m pip install "cmpl[viz]"
+python -m pip install "cmpl[io]"
 ```
 
-### Browse or display a 3D MRI volume
+### Convert a DICOM series to NIfTI
+
+CMPL supports direct conversion of both conventional and Enhanced DICOM series to NIfTI.
+
+The converter:
+
+- detects the DICOM representation automatically
+- preserves spatial geometry
+- supports single-echo and multi-echo acquisitions
+- writes a NIfTI image
+- writes a matching JSON metadata sidecar
+- orders multi-echo volumes by echo time
 
 ```python
-from cmpl.visualization import plot_3D_mri
+import cmpl
 
-plot_3D_mri(
-    volume,
-    slice_number=volume.shape[2] // 2,
-    alpha=0.5,
-    direction="sagittal",
-    cmap="gray",
-    vmin=0,
-    vmax=1,
-    dpi=300,
+metadata = cmpl.io.dicom_to_nifti(
+    "/path/to/dicom_series",
+    "output.nii.gz",
 )
 ```
 
-If an interactive Matplotlib backend is available, `plot_3D_mri` can use interactive controls. Otherwise it falls back to static redraw mode.
+This creates:
 
+```text
+output.nii.gz
+output.json
+```
 
-### Compare images side by side
+If the output path does not end in `.nii` or `.nii.gz`, CMPL appends `.nii.gz`.
+
+For a single echo, the output is a 3D image. For a multi-echo acquisition, CMPL writes a 4D NIfTI with echoes in the last dimension:
+
+```text
+x, y, z, echo
+```
+
+The matching JSON sidecar contains acquisition metadata and source-geometry information. For multi-echo data, echo times are stored in milliseconds under:
+
+```json
+{
+  "Acquisition": {
+    "EchoTimes": [2.5, 5.0, 7.5, 10.0],
+    "TimeUnit": "ms"
+  }
+}
+```
+
+If a directory contains multiple DICOM series, select a specific `SeriesInstanceUID`:
 
 ```python
-from cmpl.visualization import side_by_side_view
+metadata = cmpl.io.dicom_to_nifti(
+    "/path/to/dicom_directory",
+    "output.nii.gz",
+    series_id="1.2.840...",
+)
+```
 
-side_by_side_view(
-    image_a,
-    image_b,
-    titles=["Reference", "Reconstruction"],
-    color_palette="gray",
+### Command-line DICOM conversion
+
+The I/O extra installs:
+
+```text
+cmpl-dicom-to-nifti
+```
+
+Convert a DICOM series with automatic conventional/Enhanced-DICOM detection:
+
+```bash
+cmpl-dicom-to-nifti /path/to/dicom_series
+```
+
+The same CLI can be invoked as a Python module:
+
+```bash
+python -m cmpl.cli.dicom_to_nifti /path/to/dicom_series
+```
+
+If the output path is omitted, CMPL writes the NIfTI and JSON sidecar to the current directory using the DICOM directory name:
+
+```text
+./<series_directory_name>.nii.gz
+./<series_directory_name>.json
+```
+
+Specify an explicit output path if needed:
+
+```bash
+cmpl-dicom-to-nifti \
+    /path/to/dicom_series \
+    /path/to/output.nii.gz
+```
+
+Progress output is enabled by default. Disable it with:
+
+```bash
+cmpl-dicom-to-nifti /path/to/dicom_series --no-verbose
+```
+
+The same command handles conventional single-frame DICOM and Enhanced multi-frame DICOM.
+
+### Read a NIfTI file
+
+```python
+from cmpl.utilities.io import nifti_read
+
+nifti_image, data = nifti_read("image.nii.gz")
+```
+
+### Replace NIfTI data while preserving geometry
+
+```python
+from cmpl.utilities.io import update_nifti_data
+
+updated = update_nifti_data(
+    "reference.nii.gz",
+    new_data,
+    output_path="updated.nii.gz",
 )
 ```
 
-### Overlay a segmentation
+### Save a scalar map using reference NIfTI geometry
 
 ```python
-from cmpl.visualization import visualize_segmentation_slice
+from cmpl.utilities.io import save_scalar_map_like
 
-visualize_segmentation_slice(
-    grayscale_image,
-    segmentation,
-    slice_number=20,
-    dimension="axial",
+save_scalar_map_like(
+    reference_image,
+    scalar_map,
+    "map.nii.gz",
 )
 ```
 
-## Quantitative MRI
+This is useful for quantitative maps such as T2* and S0 because the spatial geometry of the source NIfTI is preserved.
 
-Quantitative MRI functionality is available under:
+### Load a DICOM directory as a NumPy array
 
 ```python
-cmpl.qmr
+from cmpl.utilities.io import load_dicom_scan_from_dir
+
+volume = load_dicom_scan_from_dir(
+    "/path/to/dicom_directory",
+    reshape=True,
+)
 ```
 
-Install the PyTorch and visualization dependencies:
+For multi-echo data, the loader can return:
 
-```bash
-python -m pip install "cmpl[torch,viz]"
+```text
+x, y, z, echo
 ```
 
-### Reconstruct a multi-echo signal from T2* and S0 maps
+depending on the acquisition metadata and requested reshaping behavior.
+
+### Read a DICOM series as SimpleITK
 
 ```python
-import numpy as np
+from cmpl.utilities.io import dicom_to_SimpleITK
 
-from cmpl.quantitative_MRI import reconstruct_images
+image = dicom_to_SimpleITK("/path/to/dicom_directory")
+```
 
-t2_star = np.full((64, 64, 8), 20.0, dtype=np.float32)
-s0 = np.full((64, 64, 8), 100.0, dtype=np.float32)
-echo_times = np.array([0.0, 5.0, 10.0, 15.0], dtype=np.float32)
+The returned image is 3D for single-echo data and 4D when multiple echoes are detected.
 
-images = reconstruct_images(
-    t2_star,
-    s0,
-    echo_times,
-    device="cpu",
-    return_numpy=True,
+### Write a SimpleITK image as NIfTI
+
+```python
+from cmpl.utilities.io import itk_to_nifti
+
+output_path = itk_to_nifti(
+    image,
+    "output.nii.gz",
 )
+```
 
-print(images.shape)
-# (64, 64, 8, 4)
+### DICOM geometry and metadata helpers
+
+CMPL separates DICOM geometry and acquisition-metadata handling into dedicated modules under `cmpl.dicom`.
+
+```python
+from cmpl.dicom import (
+    extract_slice_geometry,
+    get_slice_position,
+)
+
+geometry = extract_slice_geometry("slice001.dcm")
+position = get_slice_position("slice001.dcm")
+```
+
+Enhanced-DICOM helpers are also available:
+
+```python
+from cmpl.dicom.enhanced_dicom import (
+    get_slice_thickness,
+    get_spacing_between_slices,
+    voxel_sizes_detailed,
+)
+
+details = voxel_sizes_detailed(dataset)
 ```
 
-The signal model is:
+---
+
+## Quantitative MRI
+
+Quantitative MRI functionality is available under:
+
+```python
+cmpl.qmr
+```
+
+Install PyTorch support:
+
+```bash
+python -m pip install "cmpl[torch]"
+```
+
+For NIfTI-based quantitative MRI workflows:
+
+```bash
+python -m pip install "cmpl[io,torch]"
+```
+
+### Signal model
+
+The current two-parameter T2* implementation uses the mono-exponential signal model:
 
 ```text
 S(TE) = S0 * exp(-TE / T2*)
 ```
 
+where:
+
+- `S0` is the extrapolated signal at TE = 0
+- `T2*` is the transverse relaxation time
+- TE and T2* must use the same time unit
+
+CMPL conventionally uses milliseconds for T2* workflows.
+
 ### Fit a 3D two-parameter T2* model
 
 ```python
@@ -271,7 +439,133 @@ t2_star_map = result["T2_star_map"]
 s0_map = result["S0_map"]
 ```
 
-If CUDA is available and no device is supplied, the function can select a CUDA device automatically. CUDA usage will increase computation speed significantly.
+The expected image layout is:
+
+```text
+x, y, z, echo
+```
+
+If CUDA is available and no device is supplied, the fitter can select CUDA automatically.
+
+### Command-line 3D T2* mapping
+
+CMPL includes a command-line interface for calculating T2* and S0 maps directly from a 4D multi-echo NIfTI file and its JSON metadata sidecar.
+
+Install the required dependencies:
+
+```bash
+python -m pip install "cmpl[io,torch]"
+```
+
+Given:
+
+```text
+multi_echo.nii.gz
+multi_echo.json
+```
+
+run:
+
+```bash
+cmpl-t2star multi_echo.nii.gz
+```
+
+The JSON sidecar is detected automatically when it has the same basename as the NIfTI file.
+
+The CLI reads echo times from:
+
+```json
+{
+  "Acquisition": {
+    "EchoTimes": [2.5, 5.0, 7.5, 10.0],
+    "TimeUnit": "ms"
+  }
+}
+```
+
+The input NIfTI must be 4D:
+
+```text
+x, y, z, echo
+```
+
+and the number of entries in `EchoTimes` must match the number of volumes in the fourth dimension.
+
+The command writes:
+
+```text
+multi_echo_T2star.nii.gz
+multi_echo_S0.nii.gz
+```
+
+The T2* map is written in milliseconds. The S0 map retains the signal-intensity units of the input data. Output maps preserve the spatial geometry of the source NIfTI.
+
+Specify a different JSON file:
+
+```bash
+cmpl-t2star multi_echo.nii.gz \
+    --json metadata.json
+```
+
+Specify a custom output prefix:
+
+```bash
+cmpl-t2star multi_echo.nii.gz \
+    -o results/subject01
+```
+
+This creates:
+
+```text
+results/subject01_T2star.nii.gz
+results/subject01_S0.nii.gz
+```
+
+Request CUDA explicitly:
+
+```bash
+cmpl-t2star multi_echo.nii.gz --device cuda
+```
+
+If no device is specified, CMPL uses CUDA when available and otherwise uses CPU.
+
+Optimization settings can also be adjusted:
+
+```bash
+cmpl-t2star multi_echo.nii.gz \
+    --device cuda \
+    --iterations 10000 \
+    --lr 0.01 \
+    --initial-t2star 20
+```
+
+If echo times are present but not ordered, the CLI sorts the echo times and their corresponding NIfTI volumes together before fitting.
+
+### Reconstruct a multi-echo signal from T2* and S0 maps
+
+```python
+import numpy as np
+
+from cmpl.quantitative_MRI import reconstruct_images
+
+t2_star = np.full((64, 64, 8), 20.0, dtype=np.float32)
+s0 = np.full((64, 64, 8), 100.0, dtype=np.float32)
+echo_times = np.array(
+    [0.0, 5.0, 10.0, 15.0],
+    dtype=np.float32,
+)
+
+images = reconstruct_images(
+    t2_star,
+    s0,
+    echo_times,
+    device="cpu",
+    return_numpy=True,
+)
+
+print(images.shape)
+# (64, 64, 8, 4)
+```
 
 ### Calculate normalized fitting error
 
@@ -286,7 +580,11 @@ rmse_pct, rse_pct = calculate_rmse_percentage_s0(
 )
 ```
 
-CMPL also contains two- and three-parameter 2D/3D T2* fitting functions.
+CMPL also contains additional 2D/3D T2* fitting functions.
+
+Plotting is optional. Matplotlib is imported only when plotting is requested.
+
+---
 
 ## Reconstruction
 
@@ -296,7 +594,7 @@ Reconstruction functionality is available under:
 cmpl.recon
 ```
 
-PyTorch is required for the current reconstruction implementations:
+Install PyTorch support:
 
 ```bash
 python -m pip install "cmpl[torch]"
@@ -316,7 +614,7 @@ reconstructed_kspace = grappa_1d_recon(
 )
 ```
 
-`calibration_kspace` and `undersampled_kspace` are expected to contain coil-resolved k-space data. The current implementation uses the ordering:
+The current implementation expects coil-resolved k-space in the order:
 
 ```text
 frequency, phase, slice, coils
@@ -338,7 +636,7 @@ reconstructed_kspace = grappa_2d_recon(
 ### Conjugate-gradient SENSE
 
 ```python
-from cmpl.reconstruction.sense import CG_sense_2D
+from cmpl.reconstruction.sense.cg import CG_sense_2D
 
 reconstructed_image = CG_sense_2D(
     undersampled_image_space,
@@ -348,87 +646,53 @@ reconstructed_image = CG_sense_2D(
 
 Inputs to the current SENSE implementation are PyTorch tensors.
 
-## I/O
-
-Install the I/O extra:
-
-```bash
-python -m pip install "cmpl[io]"
-```
-
-### Read a NIfTI file
-
-```python
-from cmpl.utilities.io import nifti_read
+---
 
-nifti_image, data = nifti_read("image.nii.gz")
-```
-
-### Replace NIfTI data while preserving geometry
+## Visualization
 
-```python
-from cmpl.utilities.io import update_nifti_data
+Install the visualization extra:
 
-updated = update_nifti_data(
-    "reference.nii.gz",
-    new_data,
-    output_path="updated.nii.gz",
-)
+```bash
+python -m pip install "cmpl[viz]"
 ```
 
-### Load a DICOM directory
+### Browse or display a 3D MRI volume
 
 ```python
-from cmpl.utilities.io import load_dicom_scan_from_dir
+from cmpl.visualization import plot_3D_mri
 
-volume = load_dicom_scan_from_dir(
-    "/path/to/dicom_directory",
-    reshape=True,
+plot_3D_mri(
+    volume,
+    slice_number=volume.shape[2] // 2,
+    alpha=0.5,
+    direction="sagittal",
+    cmap="gray",
+    vmin=0,
+    vmax=1,
+    dpi=300,
 )
 ```
 
-For multi-echo data, the loader can return data arranged as:
-
-```text
-x, y, z, echo
-```
-
-depending on the acquisition metadata and requested reshaping behavior.
-
-### DICOM to SimpleITK
-
-```python
-from cmpl.utilities.io import dicom_to_SimpleITK
-
-image = dicom_to_SimpleITK("/path/to/dicom_directory")
-```
+If an interactive Matplotlib backend is available, `plot_3D_mri` can use interactive controls. Otherwise it falls back to static redraw mode.
 
-### Write a SimpleITK image as NIfTI
+### Compare images side by side
 
 ```python
-from cmpl.utilities.io import itk_to_nifti
+from cmpl.visualization import side_by_side_view
 
-output_path = itk_to_nifti(
-    image,
-    "output.nii.gz",
+side_by_side_view(
+    image_a,
+    image_b,
+    titles=["Reference", "Reconstruction"],
+    color_palette="gray",
 )
 ```
 
-### Enhanced-DICOM helpers
-
-```python
-from cmpl.dicom.enhanced_dicom import (
-    get_slice_thickness,
-    get_spacing_between_slices,
-    voxel_sizes_detailed,
-)
-
-details = voxel_sizes_detailed(dataset)
-```
+---
 
 ## Numerical utilities
 
-Lightweight numerical helpers are kept separate from heavier I/O modules so visualization and other numerical workflows do not require unrelated optional dependencies.
+Lightweight numerical helpers are kept separate from heavier I/O modules.
 
 ```python
 from cmpl.utilities.numerical import resize_matrix
@@ -439,15 +703,17 @@ resized = resize_matrix(
 )
 ```
 
-`resize_matrix` accepts NumPy arrays and PyTorch tensors. PyTorch is imported at runtime only when a Torch tensor is actually passed to the function.
+`resize_matrix` accepts NumPy arrays and PyTorch tensors. PyTorch is imported only when a Torch tensor is actually passed.
 
-For backward compatibility, older imports such as:
+For backward compatibility:
 
 ```python
 from cmpl.utilities.utils import resize_matrix
 ```
 
-continue to work.
+continues to work.
+
+---
 
 ## Data indexing
 
@@ -457,7 +723,7 @@ Install the data extra:
 python -m pip install "cmpl[data]"
 ```
 
-CMPL includes a pandas-based utility for indexing a directory tree that follows the CMPL medical-data convention:
+CMPL includes a pandas-based utility for indexing directory trees that follow the CMPL medical-data convention:
 
 ```python
 from cmpl.utilities.df_build import build_medical_data_frame
@@ -465,28 +731,26 @@ from cmpl.utilities.df_build import build_medical_data_frame
 df = build_medical_data_frame("/path/to/root")
 ```
 
-The utility is designed around a structure such as:
+The expected structure is similar to:
 
 ```text
 root/
 ├── Study001/
 │   ├── Dicoms/
 │   │   └── <contrast>/
-│   ├── h5_files/
-│   │   └── <contrast>.h5
-│   └── Segmentations/
-│       └── <contrast>/
-│           └── <group>/
-│               └── <segmentation>.nii.gz
+│   └── h5_files/
+│       └── <contrast>.h5
 └── Study002/
     └── ...
 ```
 
-This utility is convention-specific rather than a general filesystem indexer.
+This utility is convention-specific rather than a general-purpose filesystem indexer.
+
+---
 
 ## Lazy loading and optional dependencies
 
-CMPL is designed so that unrelated optional packages are not imported simply because the top-level package is imported.
+CMPL is designed so unrelated optional packages are not imported simply because the top-level package is imported.
 
 For example:
 
@@ -494,9 +758,13 @@ For example:
 import cmpl
 ```
 
-does not immediately require PyTorch, Matplotlib, pandas, nibabel, pydicom, SimpleITK, or h5py.
+does not immediately import PyTorch, Matplotlib, pandas, nibabel, pydicom, SimpleITK, h5py, or the Jupyter visualization stack.
+
+Optional functionality is loaded only when the corresponding module or function is accessed.
 
-Optional functionality is loaded when its corresponding module or function is accessed. This keeps startup lightweight and allows users to install only the dependencies required for their workflow.
+Within quantitative MRI, Matplotlib is also loaded lazily: non-plotting T2* workflows do not require Matplotlib.
+
+---
 
 ## Development
 
@@ -506,40 +774,68 @@ Clone the project and install it in editable mode with development dependencies:
 python -m pip install -e ".[dev]"
 ```
 
-For development across the currently tested major feature groups:
+For development across the main optional feature groups:
 
 ```bash
 python -m pip install -e ".[dev,io,data,viz,torch]"
 ```
 
-Run the test suite:
+Run the full test suite:
 
 ```bash
 python -m pytest tests/ -v
 ```
 
-The test suite includes:
+The test suite covers:
 
-- lazy-import and dependency-boundary tests
-- qMRI numerical tests
-- GRAPPA and SENSE reconstruction tests
+- lazy-import and dependency-boundary behavior
+- qMRI numerical fitting
+- T2* CLI validation and NIfTI output
+- GRAPPA and SENSE reconstruction
 - visualization smoke tests
-- synthetic NIfTI, DICOM, and SimpleITK I/O tests
-- data-indexing tests
+- synthetic NIfTI, DICOM, and SimpleITK I/O
+- conventional and Enhanced multi-echo DICOM-to-NIfTI conversion
+- JSON sidecar generation
+- DICOM geometry and metadata
+- data indexing
 
 ### Build the package
 
+Build distributions:
+
 ```bash
+rm -rf build dist *.egg-info
 python -m build
+```
+
+Validate them:
+
+```bash
 python -m twine check dist/*
 ```
 
+Before publishing, it is also useful to install the built wheel into a clean environment and verify the packaged CLI commands:
+
+```bash
+cmpl-dicom-to-nifti --help
+cmpl-t2star --help
+```
+
+---
+
 ## Package layout
 
 ```text
 src/cmpl/
+├── _version.py
+├── cli/
+│   ├── __init__.py
+│   ├── dicom_to_nifti.py
+│   └── t2star.py
 ├── dicom/
-│   └── enhanced_dicom.py
+│   ├── enhanced_dicom.py
+│   ├── geometry.py
+│   └── metadata.py
 ├── quantitative_MRI/
 │   └── mapping.py
 ├── reconstruction/
@@ -558,6 +854,8 @@ src/cmpl/
     └── visualization.py
 ```
 
+---
+
 ## License
 
 See the `LICENSE` file included with the project for licensing terms.