mrzerocore 0.3.2__cp37-abi3-win32.whl → 0.4.4__cp37-abi3-win32.whl

MRzeroCore/__init__.py

@@ -11,9 +11,12 @@ from .phantom.voxel_grid_phantom import VoxelGridPhantom
 from .phantom.custom_voxel_phantom import CustomVoxelPhantom
 from .phantom.sim_data import SimData
 from .phantom.brainweb import generate_brainweb_phantoms
+from .phantom.nifti_phantom import NiftiPhantom, NiftiTissue, NiftiRef, NiftiMapping
+from .phantom.tissue_dict import TissueDict
 from .simulation.isochromat_sim import isochromat_sim
 from .simulation.pre_pass import compute_graph, compute_graph_ext, Graph
 from .simulation.main_pass import execute_graph
+from .simulation.sig_to_mrd import sig_to_mrd
 from .reconstruction import reco_adjoint
 from .pulseq.exporter import pulseq_write_cartesian
 from . import util

MRzeroCore/phantom/brainweb/.gitignore

@@ -0,0 +1 @@
+brainweb*/

MRzeroCore/phantom/brainweb/__init__.py

@@ -1,25 +1,18 @@
-from typing import Literal
-import json
-import gzip
-import requests
-import os
 import numpy as np
+from pathlib import Path
 
 
-# Load the brainweb data file that contains info about tissues, subjects, ...
-brainweb_data_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
-                                  "brainweb_data.json")
-brainweb_data = json.load(open(brainweb_data_path))
+def load_tissue(subject: int, alias: str, cache_dir: Path) -> np.ndarray:
+    import os
+    import requests
+    import gzip
 
-
-def load_tissue(subject: int, alias: str, cache_dir: str) -> np.ndarray:
     download_alias = f"subject{subject:02d}_{alias}"
     file_name = download_alias + ".i8.gz"  # 8 bit signed int, gnuzip
-    file_path = os.path.join(cache_dir, file_name)
+    file_path = cache_dir / file_name
 
     # Download and cache file if it doesn't exist yet
     if not os.path.exists(file_path):
-        print(f"Downloading '{download_alias}'", end="", flush=True)
         response = requests.post(
             "https://brainweb.bic.mni.mcgill.ca/cgi/brainweb1",
             data={
@@ -30,75 +23,56 @@ def load_tissue(subject: int, alias: str, cache_dir: str) -> np.ndarray:
         )
         with open(file_path, "wb") as f:
             f.write(response.content)
-        print(" - ", end="")
 
     # Load the raw BrainWeb data and add it to the return array
     with gzip.open(file_path) as f:
-        print(f"Loading {os.path.basename(file_path)}", end="", flush=True)
         # BrainWeb says this data is unsigned, which is a lie
         tmp = np.frombuffer(f.read(), np.uint8) + 128
 
     # Vessel bugfix: most of background is 1 instead of zero
     if alias == "ves":
         tmp[tmp == 1] = 0
-    data = tmp.reshape(362, 434, 362).swapaxes(0, 2).astype(np.float32)
-
-    print(" - done")
-    return data / 255.0
-
-
-def gen_noise(range: float, res: np.ndarray) -> np.ndarray:
-    if range == 0:
-        return 1
-    else:
-        freq = 20
-        padded_res = (res + freq - 1) // freq * freq
-        try:
-            from perlin_numpy import generate_perlin_noise_3d
-            noise = generate_perlin_noise_3d(padded_res, (freq, freq, freq))
-        except:
-            print("perlin_numpy@git+https://github.com/pvigier/perlin-numpy")
-            print("is not installed, falling back to numpy.random.random()")
-            noise = np.random.random(padded_res)
-        return 1 + range * noise[:res[0], :res[1], :res[2]]
-
+    
+    # Convert to RAS+ [x, y, z] indexing and [0..1] range
+    data = tmp.reshape(362, 434, 362).swapaxes(0, 2).astype(np.float32) / 255.0
 
-def downsample(array: np.ndarray, factor: int) -> np.ndarray:
-    # crop array to multiple of factor
-    shape = (np.array(array.shape) // factor) * factor
-    array = array[:shape[0], :shape[1], :shape[2]]
+    return data
 
-    tmp = np.zeros(shape // factor)
-    for x in range(factor):
-        for y in range(factor):
-            for z in range(factor):
-                tmp += array[x::factor, y::factor, z::factor]
 
-    return tmp / factor**3
+def generate_B0_B1(mask):
+    """Generate a somewhat plausible B0 and B1 map.
 
-
-def generate_brainweb_phantoms(
-        output_dir: str,
-        config: Literal["3T", "7T-noise", "3T-highres-fat"] = "3T"):
+    Visually fitted to look similar to the numerical_brain_cropped
+    """
+    x_pos, y_pos, z_pos = np.meshgrid(
+        np.linspace(-1, 1, mask.shape[0]),
+        np.linspace(-1, 1, mask.shape[1]),
+        np.linspace(-1, 1, mask.shape[2]),
+        indexing="ij"
+    )
+    B1 = np.exp(-(0.4*x_pos**2 + 0.2*y_pos**2 + 0.3*z_pos**2))
+    dist2 = (0.4*x_pos**2 + 0.2*(y_pos - 0.7)**2 + 0.3*z_pos**2)
+    B0 = 7 / (0.05 + dist2) - 45 / (0.3 + dist2)
+
+    # Normalize such that the average over the mask is 0 or 1
+    
+    B0 -= B0[mask].mean()
+    B1 /= B1[mask].mean()
+    B0[~mask] = 0
+    B1[~mask] = 0
+
+    return B0, B1
+
+
+def generate_brainweb_phantoms(output_dir: str, subject_count: int | None = None):
     """Generate BrainWeb phantom maps for the selected configuration.
 
     Raw tissue segmentation data is provided by the BrainWeb Database:
     http://www.bic.mni.mcgill.ca/brainweb/
 
-    All tissue data etc. are stored in [brainweb_data.json](https://github.com/MRsources/MRzero-Core/blob/main/python/MRzeroCore/phantom/brainweb/brainweb_data.json).
-    To ensure consistent configurations and reproducible results, available
-    configs are stored in this file as well. They specify which field strength
-    to use, which tissues to include, and the downsampling and noise levels.
-
-    The emitted files are compressed numpy files, which can be loaded with
-    ``np.load(file_name)``. They contain the following arrays:
-
-     - `PD_map`: Proton Density [a.u.]
-     - `T1_map`: T1 relaxation time [s]
-     - `T2_map`: T2 relaxation time [s]
-     - `T2dash_map`: T2' relaxation time [s]
-     - `D_map`: Isotropic Diffusion coefficient [10^-3 mm² / s]
-     - `tissue_XY`: Tissue segmentation for all included tissues
+    The generated phantoms are stored as MR-zero
+    [NIfTI phantoms](https://mrsources.github.io/MRzero-Core/nifti-overview.html).
+    Settings for the generated phantoms are stored in `brainweb_data.json`.
 
     Parameters
     ----------
@@ -107,65 +81,112 @@ def generate_brainweb_phantoms(
         addition, a `cache` folder will be generated there too, which contains
         all the data downloaded from BrainWeb to avoid repeating the download
         for all configurations or when generating phantoms again.
-    config: ["3T", "7T-noise", "3T-highres-fat"]
-        The configuration for which the maps are generated.
+    subject_count: int
+        Number of phantoms to generate. BrainWeb provides 20 different segmented
+        phantoms. If you don't need as many, you can lower this number to only
+        generate the first `count` phantoms. If `None`, all phantoms are generated.
     """
-    config_data = brainweb_data["configs"][config]
-    cache_dir = os.path.join(output_dir, "cache")
-
-    try:
-        os.makedirs(cache_dir)
-    except FileExistsError:
-        pass
-
-    # Map resolution:
-    res = np.array([362, 434, 362]) // config_data["downsample"]
-
-    def noise() -> np.ndarray:
-        return gen_noise(config_data["noise"], res)
-
-    for subject in brainweb_data["subjects"]:
-        print(f"Generating '{config}', subject {subject}")
-        maps = {
-            "FOV": np.array([0.181, 0.217, 0.181]),
-            "PD_map": np.zeros(res, dtype=np.float32),
-            "T1_map": np.zeros(res, dtype=np.float32),
-            "T2_map": np.zeros(res, dtype=np.float32),
-            "T2dash_map": np.zeros(res, dtype=np.float32),
-            "D_map": np.zeros(res, dtype=np.float32),
-        }
-
-        for tissue in config_data["tissues"]:
-            tissue_map = sum([
-                load_tissue(subject, alias, cache_dir)
-                for alias in brainweb_data["download-aliases"][tissue]
-            ])
-            tissue_map = downsample(tissue_map, config_data["downsample"])
-            maps["tissue_" + tissue] = tissue_map
-
-            field_strength = config_data["field-strength"]
-            tissue_data = brainweb_data["tissues"][field_strength][tissue]
-
-            # Separate noise maps is slower but uncorrelated.
-            # Might be better for training or worse - could be configurable
-            print("Adding tissue to phantom", end="", flush=True)
-            maps["PD_map"] += tissue_data["PD"] * tissue_map * noise()
-            maps["T1_map"] += tissue_data["T1"] * tissue_map * noise()
-            maps["T2_map"] += tissue_data["T2"] * tissue_map * noise()
-            maps["T2dash_map"] += tissue_data["T2'"] * tissue_map * noise()
-            maps["D_map"] += tissue_data["D"] * tissue_map * noise()
-            print(" - done")
-
-        file = os.path.join(output_dir, f"subject{subject:02d}_{config}.npz")
-        print(f"Saving to '{os.path.basename(file)}'", end="", flush=True)
-        np.savez_compressed(file, **maps)
-        print(" - done\n")
-
-
-if __name__ == "__main__":
-    print("This is for testing only, use generate_brainweb_phantoms directly!")
-    file_dir = os.path.dirname(os.path.realpath(__file__))
-    output_dir = os.path.join(file_dir, "output")
-
-    for config in brainweb_data["configs"].keys():
-        generate_brainweb_phantoms(output_dir, config)
+    import os
+    import json
+    from tqdm import tqdm
+    import nibabel as nib
+    from ..nifti_phantom import NiftiPhantom, NiftiTissue, NiftiRef, NiftiMapping
+
+    cache_dir = Path(output_dir) / "cache"
+    config_file = Path(__file__).parent / "brainweb_data.json"
+    os.makedirs(cache_dir, exist_ok=True)
+
+    # Load the brainweb data file that contains info about tissues and subjects
+    with open(config_file) as f:
+        config = json.load(f)
+
+    if subject_count is None:
+        subject_count = len(config["subjects"])
+
+    # Voxel index to physical coordinates in millimeters:
+    # Brainweb has 0.5 mm voxel size; we center the brain.
+    affine = np.array(
+        [
+            [0.5, 0, 0, -90.5],  # X: Right
+            [0, 0.5, 0, -108.5], # Y: Anterior
+            [0, 0, 0.5, -90.5],  # Z: Superior
+            [0, 0, 0, 0],        # ignored
+        ]
+    )
+
+
+    number_of_downloads = subject_count * sum(len(maps) for maps in config["download-aliases"].values())
+    number_of_saves = subject_count * 3  # density, B0, B1
+    number_of_jsons = subject_count * len(config["fields"])
+    total = number_of_downloads + number_of_saves + number_of_jsons
+
+    with tqdm(total=total) as pbar:
+        for subject in config["subjects"][:subject_count]:
+            phantom_name = f"brainweb-subj{subject:02d}"
+            phantom_dir = Path(output_dir) / phantom_name
+
+            pbar.set_description(str(phantom_dir))
+            os.makedirs(phantom_dir, exist_ok=True)
+
+            tissue_indices = {}
+            density_maps = []
+            for tissue, density in config["density"].items():
+                density_map = 0
+
+                for alias in config["download-aliases"][tissue]:
+                    pbar.set_postfix_str(f"loading 'subject{subject:02d}_{alias}'")
+                    density_map += density * load_tissue(subject, alias, cache_dir)
+                    pbar.update()
+
+                tissue_indices[tissue] = len(density_maps)
+                density_maps.append(density_map)
+
+            pbar.set_postfix_str(f"saving '{phantom_name}.nii.gz'")
+            nib.loadsave.save(
+                nib.nifti1.Nifti1Image(np.stack(density_maps, -1), affine),
+                phantom_dir / f"{phantom_name}.nii.gz"
+            )
+            pbar.update()
+
+            B0, B1 = generate_B0_B1(sum(density_maps) > 0)
+            pbar.set_postfix_str(f"saving '{phantom_name}_dB0.nii.gz'")
+            nib.loadsave.save(
+                nib.nifti1.Nifti1Image(B0[..., None], affine),
+                phantom_dir / f"{phantom_name}_dB0.nii.gz"
+            )
+            pbar.update()
+            pbar.set_postfix_str(f"saving '{phantom_name}_B1+.nii.gz'")
+            nib.loadsave.save(
+                nib.nifti1.Nifti1Image(B1[..., None], affine),
+                phantom_dir / f"{phantom_name}_B1+.nii.gz"
+            )
+            pbar.update()
+
+            for field in config["fields"]:
+                phantom = NiftiPhantom.default(B0=field)
+                pbar.set_postfix_str(f"saving '{phantom_name}-{field}T.json'")
+                density_maps = []
+
+                for tissue in config["tissues"]:
+                    tissue_config = config["props"][str(field)][tissue]
+
+                    phantom.tissues[tissue] = NiftiTissue(
+                        density=NiftiRef(Path(f"{phantom_name}.nii.gz"), tissue_indices[tissue]),
+                        T1=tissue_config["T1"],
+                        T2=tissue_config["T2"],
+                        T2dash=tissue_config["T2'"],
+                        ADC=tissue_config["ADC"],
+                        dB0=NiftiRef(Path(f"{phantom_name}_dB0.nii.gz"), 0),
+                        B1_tx=[NiftiRef(Path(f"{phantom_name}_B1+.nii.gz"), 0)],
+                        B1_rx=[1.0],
+                    )
+                    if tissue == "fat":
+                        phantom.tissues["fat"].dB0 = NiftiMapping(
+                            file=NiftiRef(Path(f"{phantom_name}_dB0.nii.gz"), 0),
+                            func=config["dB0-fat-remap"][str(field)]
+                        )
+
+                phantom.save(phantom_dir / f"{phantom_name}-{field}T.json")
+                pbar.update()
+        
+        pbar.close()

MRzeroCore/phantom/brainweb/brainweb_data.json

@@ -1,92 +1,91 @@
 {
-  "configs": {
-    "3T": {
-      "field-strength": "3T",
-      "tissues": ["gm", "wm", "csf"],
-      "downsample": 3,
-      "noise": 0
-    },
-    "7T-noise": {
-      "field-strength": "7T",
-      "tissues": ["gm", "wm", "csf"],
-      "downsample": 3,
-      "noise": 0.2
-    },
-    "3T-highres-fat": {
-      "field-strength": "3T",
-      "tissues": ["gm", "wm", "csf", "fat"],
-      "downsample": 1,
-      "noise": 0
-    }
-  },
   "subjects": [
     4, 5, 6, 18, 20, 38, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54
   ],
+  "fields": [3, 7],
+  "tissues": ["gm", "wm", "csf", "vessels", "fat"],
   "download-aliases": {
     "gm": ["gry"],
     "wm": ["wht"],
-    "csf": ["csf", "ves"],
+    "csf": ["csf"],
+    "vessels": ["ves"],
     "fat": ["fat", "mus", "m-s", "dura", "fat2"]
   },
-  "tissues": {
-    "3T": {
+  "dB0-fat-remap" : {
+    "3": "x - 440",
+    "7": "x - 1020"
+  },
+  "density": {
+    "gm": 0.8,
+    "wm": 0.7,
+    "csf": 1.0,
+    "vessels": 1.0,
+    "fat": 1.0
+  },
+
+  "props": {
+    "3": {
       "gm": {
-        "PD": 0.8,
         "T1": 1.56,
         "T2": 0.083,
         "T2'": 0.32,
-        "D": 0.83
+        "ADC": 0.83
       },
       "wm": {
-        "PD": 0.7,
         "T1": 0.83,
         "T2": 0.075,
         "T2'": 0.18,
-        "D": 0.65
+        "ADC": 0.65
       },
       "csf": {
-        "PD": 1,
         "T1": 4.16,
         "T2": 1.65,
         "T2'": 0.059,
-        "D": 3.19
+        "ADC": 3.19
+      },
+      "vessels": {
+        "T1": 4.16,
+        "T2": 1.65,
+        "T2'": 0.059,
+        "ADC": 3.19
       },
       "fat": {
-        "PD": 1,
         "T1": 0.37,
         "T2": 0.125,
         "T2'": 0.012,
-        "D": 0.1
+        "ADC": 0.1
       }
     },
-    "7T": {
+    "7": {
       "gm": {
-        "PD": 0.8,
         "T1": 1.67,
         "T2": 0.043,
         "T2'": 0.82,
-        "D": 0.83
+        "ADC": 0.83
       },
       "wm": {
-        "PD": 0.7,
         "T1": 1.22,
         "T2": 0.037,
         "T2'": 0.65,
-        "D": 0.65
+        "ADC": 0.65
       },
       "csf": {
-        "PD": 1,
         "T1": 4.0,
         "T2": 0.8,
         "T2'": 0.204,
-        "D": 3.19
+        "ADC": 3.19
+      },
+      "vessels": {
+        "T1": 4.0,
+        "T2": 0.8,
+        "T2'": 0.204,
+        "ADC": 3.19
       },
       "fat": {
-        "PD": 1,
         "T1": 0.374,
         "T2": 0.125,
         "T2'": 0.0117,
-        "D": 0.1
+        "ADC": 0.1
       }
     }
   }

MRzeroCore/phantom/custom_voxel_phantom.py

@@ -148,32 +148,9 @@ class CustomVoxelPhantom:
 
     def generate_PD_map(self) -> torch.Tensor:
         """Convenience function for MRTwin_pulseq to generate a PD map."""
-        kx, ky = torch.meshgrid(
-            torch.linspace(-64, 63, 128),
-            torch.linspace(-64, 63, 128),
-        )
-        trajectory = torch.stack([
-            kx.flatten(),
-            ky.flatten(),
-            torch.zeros(kx.numel()),
-        ], dim=1)
-        PD_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
-
-        # All voxels have the same shape -> same intra-voxel dephasing
-        dephasing = build_dephasing_func(
-            self.voxel_shape, self.voxel_size
-        )(trajectory, None)
-
-        # Iterate over all voxels and render them into the kspaces
-        for i in range(self.PD.numel()):
-            rot = torch.exp(-2j*pi * (trajectory @ self.voxel_pos[i, :]))
-            kspace = (rot * dephasing).view(128, 128)
-            PD_kspace += kspace * self.PD[i]
-
-        return torch.fft.fftshift(torch.fft.ifft2(PD_kspace)).abs()[:, :, None]
+        return self.generate_maps([self.PD, ])[0].abs()[:, :, None]
 
-    def plot(self) -> None:
-        """Print and plot all data stored in this phantom."""
+    def generate_maps(self, props) -> list[torch.Tensor]:
         # Best way to accurately plot this is to generate a k-space -> FFT
         # We only render a 2D image with a FOV of 1
         kx, ky = torch.meshgrid(
@@ -185,34 +162,30 @@ class CustomVoxelPhantom:
             ky.flatten(),
             torch.zeros(kx.numel()),
         ], dim=1)
-        PD_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
-        T1_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
-        T2_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
-        T2dash_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
-        D_kspace = torch.zeros(128, 128, dtype=torch.cfloat)
 
         # All voxels have the same shape -> same intra-voxel dephasing
         dephasing = build_dephasing_func(
             self.voxel_shape, self.voxel_size
         )(trajectory, None)
 
+        kspaces = [torch.zeros(128, 128, dtype=torch.cfloat) for _ in range(len(props))]
         # Iterate over all voxels and render them into the kspaces
-        for i in range(self.PD.numel()):
-            rot = torch.exp(-2j*pi * (trajectory @ self.voxel_pos[i, :]))
-            kspace = (rot * dephasing).view(128, 128)
-            PD_kspace += kspace * self.PD[i]
-            T1_kspace += kspace * self.T1[i]
-            T2_kspace += kspace * self.T2[i]
-            T2dash_kspace += kspace * self.T2dash[i]
-            D_kspace += kspace * self.D[i]
-
-        PD = torch.fft.fftshift(torch.fft.ifft2(PD_kspace))
-        T1 = torch.fft.fftshift(torch.fft.ifft2(T1_kspace))
-        T2 = torch.fft.fftshift(torch.fft.ifft2(T2_kspace))
-        T2dash = torch.fft.fftshift(torch.fft.ifft2(T2dash_kspace))
-        D = torch.fft.fftshift(torch.fft.ifft2(D_kspace))
-
-        maps = [PD, T1, T2, T2dash, D]
+        for pos in self.voxel_pos:
+            rot = torch.exp(-2j*pi * (trajectory @ pos))
+            
+            for i in range(len(props)):
+                kspaces[i] += props[i] * (rot * dephasing).view(128, 128)
+        
+        # FFT the rendered k-spaces to get the maps
+        norm = self.voxel_size[0] * self.voxel_size[1] # 2D plot, ignore thickness
+        return [
+            torch.fft.fftshift(torch.fft.ifft2(kspace * norm, norm="forward"))
+            for kspace in kspaces
+        ]
+
+    def plot(self) -> None:
+        """Print and plot all data stored in this phantom."""
+        maps = self.generate_maps([self.PD, self.T1, self.T2, self.T2dash, self.D])
         titles = ["PD", "T1", "T2", "T2'", "D"]
 
         print("CustomVoxelPhantom")