mrzerocore 0.3.1__tar.gz → 0.3.2__tar.gz

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/CHANGELOG.md

@@ -1,3 +1,7 @@
+- 0.3.2
+  - Added tissue maps to phantom and plotting (#68)
+  - Fixed `.plot()`ting of 3D VoxelGridPhantom, added slice parameter
+  - Added `simulate_2D` to util for easy simulation of pypulseq sequences
 - 0.3.1
   - WIP .dsv support with pydisseqt 0.1.5
   - changed type annotation in util.imshow for python 3.9 compatibility

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/Cargo.lock

@@ -59,7 +59,7 @@ dependencies = [
 
 [[package]]
 name = "mrzero_core"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "num-complex",
  "pyo3",

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mrzero_core"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: MRzeroCore
-Version: 0.3.1
+Version: 0.3.2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

MRzeroCore-0.3.2/documentation/playground/templates/binary_masks.ipynb

@@ -0,0 +1,85 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import MRzeroCore as mr0\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Generate phantoms with tissue masks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "mr0.generate_brainweb_phantoms(\"bw_phantoms\" , \"3T\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "phantom = mr0.VoxelGridPhantom.brainweb(\"bw_phantoms/subject04_3T.npz\")\n",
+    "\n",
+    "obj = phantom.interpolate(256, 256, 32).slices([16])\n",
+    "obj.plot(plot_masks=True)\n",
+    "phantom = obj.build()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# get tissue masks from phantom\n",
+    "masks = phantom.tissue_masks\n",
+    "\n",
+    "#plot tissue masks\n",
+    "plt.figure()\n",
+    "for key, value in masks.items():\n",
+    "    plt.imshow(value[:, :, 0])\n",
+    "    plt.colorbar()\n",
+    "    plt.title(key)\n",
+    "    plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "mrzero_source",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/python/MRzeroCore/phantom/sim_data.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, Any
+from typing import Callable, Any, Optional, Dict
 import torch
 from numpy import pi
 
@@ -66,7 +66,8 @@ class SimData:
         dephasing_func: Callable[[torch.Tensor, torch.Tensor], torch.Tensor],
         recover_func: Callable[[SimData], Any] | None = None,
         phantom_motion=None,
-        voxel_motion=None
+        voxel_motion=None,
+        tissue_masks: Optional[Dict[str,torch.Tensor]] = None,
     ) -> None:
         """Create a :class:`SimData` instance based on the given tensors.
 
@@ -94,6 +95,7 @@ class SimData:
         self.D = D.clamp(min=1e-6)
         self.B0 = B0.clone()
         self.B1 = B1.clone()
+        self.tissue_masks = tissue_masks
         self.coil_sens = coil_sens.clone()
         self.size = size.clone()
         self.voxel_pos = voxel_pos.clone()
@@ -126,7 +128,12 @@ class SimData:
             self.dephasing_func,
             self.recover_func,
             self.phantom_motion,
-            self.voxel_motion
+            self.voxel_motion,
+            tissue_masks=(
+                {k: v.cuda() for k, v in self.tissue_masks.items()}
+                if self.tissue_masks is not None
+                else None
+            ),
         )
 
     def cpu(self) -> SimData:
@@ -150,7 +157,12 @@ class SimData:
             self.dephasing_func,
             self.recover_func,
             self.phantom_motion,
-            self.voxel_motion
+            self.voxel_motion,
+            tissue_masks=(
+                {k: v.cpu() for k, v in self.tissue_masks.items()}
+                if self.tissue_masks is not None
+                else None
+            ),
         )
 
     @property

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/python/MRzeroCore/phantom/voxel_grid_phantom.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Literal
+from typing import Literal, Optional, Dict
 from warnings import warn
 from scipy import io
 import numpy as np
@@ -84,6 +84,8 @@ class VoxelGridPhantom:
         (coil_count, sx, sy, sz) tensor of coil sensitivities
     size : torch.Tensor
         Size of the data, in meters.
+    tissue_masks : Dict[str, torch.Tensor]
+        Segmentation masks for different tissues. The keys are the tissue names
     """
 
     def __init__(
@@ -97,6 +99,7 @@ class VoxelGridPhantom:
         B1: torch.Tensor,
         coil_sens: torch.Tensor,
         size: torch.Tensor,
+        tissue_masks: Optional[Dict[str,torch.Tensor]] = None,
     ) -> None:
         """Set the phantom attributes to the provided parameters.
 
@@ -110,6 +113,7 @@ class VoxelGridPhantom:
         self.D = torch.as_tensor(D, dtype=torch.float32)
         self.B0 = torch.as_tensor(B0, dtype=torch.float32)
         self.B1 = torch.as_tensor(B1, dtype=torch.float32)
+        self.tissue_masks = tissue_masks
         self.coil_sens = torch.as_tensor(coil_sens, dtype=torch.float32)
         self.size = torch.as_tensor(size, dtype=torch.float32)
 
@@ -167,7 +171,8 @@ class VoxelGridPhantom:
             voxel_pos,
             torch.as_tensor(shape, device=self.PD.device) / 2 / self.size,
             dephasing_func,
-            recover_func=lambda data: recover(mask, data)
+            recover_func=lambda data: recover(mask, data),
+            tissue_masks=self.tissue_masks
         )
     
     @classmethod
@@ -193,7 +198,12 @@ class VoxelGridPhantom:
                 size = torch.tensor(data['FOV'], dtype=torch.float)
             except KeyError:
                 size = torch.tensor([0.192, 0.192, 0.192])
-        
+
+            tissue_masks = {
+                key: torch.tensor(mask)
+                for key, mask in data.items()
+                if key.startswith("tissue_")
+            }
         if B1.ndim == 3:
             # Add coil-dimension
             B1 = B1[None, ...]
@@ -201,6 +211,7 @@ class VoxelGridPhantom:
         return cls(
             PD, T1, T2, T2dash, D, B0, B1,
             torch.ones(1, *PD.shape), size,
+            tissue_masks=tissue_masks
         )
 
     @classmethod
@@ -303,6 +314,9 @@ class VoxelGridPhantom:
             select(self.B1).unsqueeze(0),
             select(self.coil_sens).unsqueeze(0),
             self.size.clone(),
+            tissue_masks={
+                key: mask[..., slices] for key, mask in self.tissue_masks.items()
+                },
         )
 
     def scale_fft(self, x: int, y: int, z: int) -> VoxelGridPhantom:
@@ -342,6 +356,7 @@ class VoxelGridPhantom:
             scale(self.B1.squeeze()).unsqueeze(0),
             scale(self.coil_sens.squeeze()).unsqueeze(0),
             self.size.clone(),
+            tissue_masks= {key: scale(mask) for key, mask in self.tissue_masks.items()}
         )
 
     def interpolate(self, x: int, y: int, z: int) -> VoxelGridPhantom:
@@ -379,6 +394,18 @@ class VoxelGridPhantom:
                 output[i, ...] = resample(tensor[i, ...])
             return output
 
+        def resample_masks(tensors: Dict) -> Dict:
+            output = {}
+            for key, mask in tensors.items():
+                # Interpolate the mask
+                interpolated_mask = torch.nn.functional.interpolate(
+                    mask[None, None, ...].float(), size=(x, y, z), mode='area'
+                )[0, 0, ...]
+                # Store the result
+                output[key] = interpolated_mask
+
+            return output
+
         return VoxelGridPhantom(
             resample(self.PD),
             resample(self.T1),
@@ -389,14 +416,32 @@ class VoxelGridPhantom:
             resample_multicoil(self.B1),
             resample_multicoil(self.coil_sens),
             self.size.clone(),
+            tissue_masks=resample_masks(self.tissue_masks)
         )
 
-    def plot(self) -> None:
-        """Print and plot all data stored in this phantom."""
+    def plot(self, plot_masks=False, plot_slice="center") -> None:
+        """
+        Print and plot all data stored in this phantom.
+
+        Parameters
+        ----------
+        plot_masks : bool
+            Plot tissue masks stored in this phantom (assumes they exist)
+        slice : str | int
+            If int, the specified slice is plotted. "center" plots the center
+            slice and "all" plots all slices as a grid.
+        """
         print("VoxelGridPhantom")
         print(f"size = {self.size}")
         # Center slice
-        s = self.PD.shape[2] // 2
+        if plot_slice == "center":
+            s = self.PD.shape[2] // 2
+        elif plot_slice == "all":
+            s = slice(None)
+        elif plot_slice is int:
+            s = plot_slice
+        else:
+            raise ValueError("expected plot_slice to be 'all', 'center' or an integer")
         # Warn if we only print a part of all data
         if self.coil_sens.shape[0] > 1:
             print(f"Plotting 1st of {self.coil_sens.shape[0]} coil sens maps")
@@ -405,40 +450,68 @@ class VoxelGridPhantom:
         if self.PD.shape[2] > 1:
             print(f"Plotting slice {s} / {self.PD.shape[2]}")
 
-        plt.figure(figsize=(12, 10))
-        plt.subplot(331)
-        plt.title("PD")
+        # Determine the number of subplots needed
+        num_plots = 9  # Base number of plots without masks
+        if plot_masks:
+            num_masks = len(self.tissue_masks)
+            num_plots += num_masks
+
+        # Calculate the grid size based on the number of plots
+        cols = 3
+        rows = int(np.ceil(num_plots / cols))
 
-        imshow(self.PD, vmin=0)
+        plt.figure(figsize=(12, rows * 3))
+
+        # Plot the basic maps
+        plt.subplot(rows, cols, 1)
+        plt.title("PD")
+        imshow(self.PD[:, :, s], vmin=0)
         plt.colorbar()
-        plt.subplot(332)
+
+        plt.subplot(rows, cols, 2)
         plt.title("T1")
-        imshow(self.T1, vmin=0)
+        imshow(self.T1[:, :, s], vmin=0)
         plt.colorbar()
-        plt.subplot(333)
+
+        plt.subplot(rows, cols, 3)
         plt.title("T2")
-        imshow(self.T2, vmin=0)
+        imshow(self.T2[:, :, s], vmin=0)
         plt.colorbar()
-        plt.subplot(334)
+
+        plt.subplot(rows, cols, 4)
         plt.title("T2'")
-        imshow(self.T2dash, vmin=0)
+        imshow(self.T2dash[:, :, s], vmin=0)
         plt.colorbar()
-        plt.subplot(335)
+
+        plt.subplot(rows, cols, 5)
         plt.title("D")
-        imshow(self.D, vmin=0)
+        imshow(self.D[:, :, s], vmin=0)
         plt.colorbar()
-        plt.subplot(337)
+
+        plt.subplot(rows, cols, 7)
         plt.title("B0")
-        imshow(self.B0)
+        imshow(self.B0[:, :, s])
         plt.colorbar()
-        plt.subplot(338)
+
+        plt.subplot(rows, cols, 8)
         plt.title("B1")
-        imshow(self.B1[0, ...])
+        imshow(self.B1[0, :, :, s])
         plt.colorbar()
-        plt.subplot(339)
+
+        plt.subplot(rows, cols, 9)
         plt.title("coil sens")
-        imshow(self.coil_sens[0, ...], vmin=0)
+        imshow(self.coil_sens[0, :, :, s], vmin=0)
         plt.colorbar()
+
+        # Conditionally plot masks if plot_masks is True
+        if plot_masks:
+            for i, (key, mask) in enumerate(self.tissue_masks.items()):
+                plt.subplot(rows, cols, 10 + i)
+                plt.title(key)
+                imshow(mask)
+                plt.colorbar()
+
+        plt.tight_layout()
         plt.show()
 
     def plot3D(self, data2print: int = 0) -> None:

{MRzeroCore-0.3.1 → MRzeroCore-0.3.2}/python/MRzeroCore/util.py

@@ -342,3 +342,74 @@ def imshow(data: Union[np.ndarray, torch.Tensor], *args, **kwargs):
             data[x:x+tmp.shape[0], y:y+tmp.shape[1]] = tmp[:, :, i]
 
     plt.imshow(data.T, *args, origin="lower", **kwargs)
+
+
+def simulate_2d(seq, sim_size=None, noise_level=0, dB0=0, B0_scale=1, B0_polynomial=None):
+    # Copied and modified from https://github.com/pulseq/MR-Physics-with-Pulseq
+    import urllib
+    import MRzeroCore as mr0
+    # Download .mat file for phantom if necessary
+    sim_url = 'https://github.com/mzaiss/MRTwin_pulseq/raw/mr0-core/data/numerical_brain_cropped.mat'
+    sim_filename = os.path.basename(sim_url)
+    if not os.path.exists(sim_filename):
+        print(f'Downloading {sim_url}...')
+        urllib.request.urlretrieve(sim_url, sim_filename)
+    
+    # If seq is not a str, assume it is a sequence object and write to a temporary sequence file
+    if not isinstance(seq, str):
+        seq.write('tmp.seq')
+        seq_filename = 'tmp.seq'
+        adc_samples = int(seq.adc_library.data[1][0])
+    else:
+        seq_filename = seq
+        tmp_seq = pp.Sequence()
+        tmp_seq.read(seq_filename)
+        adc_samples = int(tmp_seq.adc_library.data[1][0])
+    
+    # Create phantom from .mat file
+    obj_p = mr0.VoxelGridPhantom.load_mat(sim_filename)
+    if sim_size is not None:
+        obj_p = obj_p.interpolate(sim_size[0], sim_size[1], 1)
+
+    # Manipulate loaded data
+    obj_p.B0 *= B0_scale
+    obj_p.B0 += dB0
+    
+    if B0_polynomial is not None:
+        x,y = torch.meshgrid(torch.linspace(-1,1,obj_p.PD.shape[0]),torch.linspace(-1,1,obj_p.PD.shape[1]))
+        
+        obj_p.B0 = B0_polynomial[0]
+        if len(B0_polynomial) > 1:
+            obj_p.B0 += x * B0_polynomial[1]
+        if len(B0_polynomial) > 2:
+            obj_p.B0 += y * B0_polynomial[2]
+        if len(B0_polynomial) > 3:
+            obj_p.B0 += x*x * B0_polynomial[3]
+        if len(B0_polynomial) > 4:
+            obj_p.B0 += y*y * B0_polynomial[4]
+        if len(B0_polynomial) > 5:
+            obj_p.B0 += x*y * B0_polynomial[5]
+        
+        obj_p.B0 = obj_p.B0[:,:,None]
+    
+    obj_p.D *= 0
+    
+    # Convert Phantom into simulation data
+    obj_p = obj_p.build()
+
+    # MR zero simulation
+    seq0 = mr0.Sequence.import_file(seq_filename)
+    
+    # Remove temporary sequence file
+    if not isinstance(seq, str):
+        os.unlink('tmp.seq')
+    
+    # Simulate the sequence
+    graph = mr0.compute_graph(seq0, obj_p, 200, 1e-5)
+    signal = mr0.execute_graph(graph, seq0, obj_p)
+
+    # Add noise to the simulated data
+    if noise_level > 0:
+        signal += noise_level * torch.randn(*signal.shape, dtype=signal.dtype)
+    
+    return signal