MRPhantom 2.2.0__tar.gz → 2.2.1__tar.gz

{mrphantom-2.2.0 → mrphantom-2.2.1/MRPhantom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRPhantom
-Version: 2.2.0
+Version: 2.2.1
 Summary: Volumetric dynamic MRI Phantom of a Slime with respiratory and cardiac motion, and M0, phase, T1, T2, B0, coil sensitivity maps, boosted by a parallel C-API Backend.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT

{mrphantom-2.2.0 → mrphantom-2.2.1}/MRPhantom.egg-info/SOURCES.txt

@@ -12,10 +12,14 @@ MRPhantom.egg-info/requires.txt
 MRPhantom.egg-info/top_level.txt
 mrphantom_src/Function.py
 mrphantom_src/__init__.py
+mrphantom_src/nmr_para.xml
+mrphantom_src/utility.py
 mrphantom_src/__pycache__/Function.cpython-312.pyc
 mrphantom_src/__pycache__/Type.cpython-312.pyc
 mrphantom_src/__pycache__/Utility.cpython-312.pyc
 mrphantom_src/__pycache__/__init__.cpython-312.pyc
 mrphantom_src/ext/main.cpp
 mrphantom_src/ext/slime.cpp
-mrphantom_src/ext/slime.h
+mrphantom_src/ext/slime.h
+test/test.py
+test/test_Simple.py

{mrphantom-2.2.0/MRPhantom.egg-info → mrphantom-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRPhantom
-Version: 2.2.0
+Version: 2.2.1
 Summary: Volumetric dynamic MRI Phantom of a Slime with respiratory and cardiac motion, and M0, phase, T1, T2, B0, coil sensitivity maps, boosted by a parallel C-API Backend.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT

mrphantom-2.2.1/mrphantom_src/Function.py

@@ -0,0 +1,372 @@
+from . import ext
+from numpy import *
+from numpy.fft import fftn, ifftn, fftshift, ifftshift
+from numpy.typing import NDArray
+from typing import *
+from scipy.signal.windows import gaussian
+from scipy.ndimage import gaussian_filter
+from . import dictNmrPara, lstTissue
+
+def genPhant(shape:Tuple, ampRes:float=0, ampCar:float=0) -> NDArray: # call C++ backend to generate a phantom
+    """
+    generate a phantom in Enum type
+    
+    Args:
+        shape: shape of the phantom (independent from FOV)
+        ampRes: respiratory motion amplitude
+        ampCar: cardiac motion amplitude
+        
+    Returns:
+        NDArray contains elements in `Tissue` enum type
+    """
+    nAx = len(shape)
+    shape = (1,)*(3-len(shape)) + shape
+    return ext.genPhant(nAx, *shape, ampRes, ampCar)
+
+def LPF(arr:NDArray, std:float) -> NDArray:
+    lstWind = []
+    for l in arr.shape:
+       lstWind.append(gaussian(l, 1/(2*pi*std)))
+    wind = ones(arr.shape)
+    for a, w in enumerate(lstWind):
+        shape = [1] * arr.ndim
+        shape[a] = len(w)
+        wind *= w.reshape(shape)
+
+    arr = fftshift(fftn(ifftshift(arr)))
+    arr *= wind
+    arr = fftshift(ifftn(ifftshift(arr)))
+    return arr
+
+def genPhMap(shape:Tuple, mean:int|float|None=None, std:int|float=pi/16) -> NDArray:
+    """
+    generate random phase map
+    
+    Args:
+        shape: shape of the phantom (independent from FOV)
+        mean: mean of the noise
+        std: std of the noise
+        
+    Returns:
+        smooth complex noise with unity magnitude
+    """
+    if mean is None: mean = random.uniform(-pi,pi)
+    mapPh = random.uniform(-pi, pi, shape)
+    mapPh = LPF(mapPh, 1/4).real
+    # normalize
+    mapPh -= mapPh.mean(); mapPh = asarray(mapPh)
+    mapPh /= mapPh.std()
+    mapPh *= std
+    mapPh += mean
+    # convert to rotation factor
+    mapPh = exp(1j*mapPh)
+    mapPh = mapPh/abs(mapPh)
+    return mapPh
+
+def genB0Map(shape:Tuple, mean:int|float=0, std:int|float=1e-6*(2*pi*42.58e6*3)) -> NDArray:
+    """
+    generate random B0 map
+    
+    Args:
+        shape: shape of the phantom (independent from FOV)
+        mean: mean of the noise
+        std: std of the noise
+        
+    Returns:
+        smooth random noise in `rad/s`
+    """
+    mapB0 = random.uniform(-1, 1, shape)
+    mapB0 = LPF(mapB0, 1/4).real
+    # normalize
+    mapB0 -= mapB0.mean(); mapB0 = asarray(mapB0)
+    mapB0 /= mapB0.std()
+    mapB0 *= std
+    mapB0 += mean
+    return mapB0
+
+def genCsm(shape:Tuple, nCh:int=12, mean:int|float|None=None, std:int|float=pi/16) -> NDArray:
+    """
+    generate random coil sensitivity map
+    
+    Args:
+        shape: shape of the phantom (independent from FOV)
+        nCh: number of coils
+        mean: mean of the noise
+        std: std of the noise
+        
+    Returns:
+        complex smooth and inhomogeneous map
+    """
+    if mean is None: mean = random.uniform(-pi,pi)
+    nAx = len(shape)
+    mapC = zeros([nCh,*shape], dtype=complex128)
+    arrCoor = meshgrid\
+    (
+        *(linspace(-0.5,0.5,s,0) for s in shape),
+        indexing="ij"
+    ); arrCoor = array(arrCoor).transpose(*arange(1,nAx+1), 0)
+    arrTht = linspace(0,2*pi,nCh,0)
+    arrCoorCoil = zeros([nCh,nAx], dtype=float64)
+    arrCoorCoil[:,-2:] = 1*array([sin(arrTht), cos(arrTht)]).T
+    if nAx == 3:
+        arrCoorCoil[0::2,0] = 0.2
+        arrCoorCoil[1::2,0] = -0.2
+    for iCh in range(nCh):
+        mapC[iCh] = genPhMap(shape, mean=mean, std=std)
+        dist = sqrt(sum((arrCoor - arrCoorCoil[iCh])**2, axis=-1))
+        mapC[iCh] *= exp(-dist)
+    return mapC
+
+def genAmp(tScan:int|float, tRes:int|float, cyc:int|float, isRand:bool=True) -> NDArray:
+    """
+    generate amplitude curve
+    
+    Args:
+        tScan: length of the signal in `s`
+        tRes: temporal resolution in `s`
+        cyc: period of the signal in `s`
+        isRand: make the signal have irregular period
+        
+    Returns:
+        generated amplitude
+    """
+    nT = around(tScan/tRes).astype(int)
+
+    if isRand:
+        arrT = sort(random.rand(nT)*tScan)
+        arrAmp = sin(2*pi/cyc*arrT)
+
+        sigma = cyc/tRes/8
+        arrAmp = gaussian_filter(arrAmp, sigma)
+    else:
+        arrT = linspace(0, tScan, nT)
+        arrAmp = sin(2*pi/cyc*arrT)
+
+    return arrAmp
+
+def genResAmp(tScan:int|float, tRes:int|float, cyc:int|float=pi/2) -> NDArray:
+    """
+    generate respiratory amplitude curve
+    
+    Args:
+        tScan: length of the signal in `s`
+        tRes: temporal resolution in `s`
+        cyc: period of the signal in `s`
+        
+    Returns:
+        generated amplitude, approx. -0.02~0.02
+    """
+    return 20e-3*genAmp(tScan, tRes, cyc, 1)
+
+def genCarAmp(tScan:int|float, tRes:int|float, cyc:int|float=1) -> NDArray:
+    """
+    generate cardiac amplitude curve
+    
+    Args:
+        tScan: length of the signal in `s`
+        tRes: temporal resolution in `s`
+        cyc: period of the signal in `s`
+        
+    Returns:
+        generated amplitude, approx. -0.01~0.01
+    """
+    return 10e-3*genAmp(tScan, tRes, cyc, 0)
+
+def fB02strB0(B0:int|float) -> str:
+    """
+    convert B0 data type from float/int to string.
+
+    Args:
+        B0: B0 in number format
+    
+    Returns:
+        B0 in string format
+    """
+    if isclose(B0,0.55): return "B0_0T55"
+    if isclose(B0,1.5): return "B0_1T5"
+    if isclose(B0,3.0): return "B0_3T"
+    if isclose(B0,5.0): return "B0_5T0"
+    if isclose(B0,9.4): return "B0_9T4"
+    raise RuntimeError("unsupported B0")
+
+def initSS_bSSFP(
+    B0: float,
+    TR: float = 5e-3,
+    FA_deg: float = 60.0,
+) -> None:
+    """
+    Precalculate and store the bSSFP steady-state signal Mss for every tissue.
+    
+    Args:
+        B0: field strength
+        TR: repetition time
+        FA_deg: flip angle in degree
+    """
+    strB0 = fB02strB0(B0)
+    FA = deg2rad(FA_deg)
+
+    for strTissue in lstTissue:
+        dictTissue = dictNmrPara[strTissue]
+
+        PD = dictTissue[strB0]["PD"]
+        T1 = dictTissue[strB0]["T1"]
+        T2 = dictTissue[strB0]["T2"]
+
+        E1 = exp(-TR / T1)
+        E2 = exp(-TR / T2)
+
+        dictTissue["Mss"] = (
+            PD
+            * (1 - E1)
+            * sqrt(E2)
+            * sin(FA)
+            / (1 - (E1 - E2) * cos(FA) - E1 * E2)
+        )
+
+def initSS_FLASH(
+    B0: float,
+    TE: float = 1e-3,
+    TR: float = 10e-3,
+    FA_deg: float = 10.0,
+) -> None:
+    """
+    Precalculate and store the FLASH steady-state signal Mss for every tissue.
+    
+    Args:
+        B0: field strength
+        TE: echo time
+        TR: repetition time
+        FA_deg: flip angle in degree
+    """
+    strB0 = fB02strB0(B0)
+    FA = deg2rad(FA_deg)
+
+    for strTissue in lstTissue:
+        dictTissue = dictNmrPara[strTissue]
+
+        PD = dictTissue[strB0]["PD"]
+        T1 = dictTissue[strB0]["T1"]
+        T2s = dictTissue[strB0]["T2s"]
+
+        E1 = exp(-TR / T1)
+        E2 = exp(-TE / T2s)
+
+        dictTissue["Mss"] = (
+            PD
+            * sin(FA)
+            * (1 - E1)
+            / (1 - cos(FA) * E1)
+            * E2
+        )
+
+def Enum2SS(arrPht:NDArray) -> NDArray:
+    """
+    get steady-state signal map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        
+    Returns:
+        steady-state signal map of the given phantom
+    """
+    mapSS = zeros_like(arrPht, dtype=float64)
+    for strTissue in lstTissue:
+        try: mapSS[arrPht==dictNmrPara[strTissue]["enum"]] = dictNmrPara[strTissue]["Mss"]
+        except KeyError: raise RuntimeError("Please call `initS_FLASH()` or `initS_bSSFP()` before `Enum2SS()`.")
+    return mapSS
+
+def Enum2Para(arrPht:NDArray, B0:str|float="B0_1T5", strPara:str="PD") -> NDArray:
+    """
+    get PD map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: "B0_0T55" / "B0_1T5" / "B0_3T" / "B0_5T" / "B0_9T4" / 0.55 / 1.5 / 3.0 / 5.0 / 9.4
+        strPara: "PD" / "T1" / "T2" / "T2s" / "ADC" / "Om"
+        
+    Returns:
+        Proton density map of the given phantom, relevant to water
+    """
+    mapPara = zeros_like(arrPht, dtype=float64)
+    if not isinstance(B0, str): B0 = fB02strB0(B0)
+    for strTissue in lstTissue:
+        mapPara[arrPht==dictNmrPara[strTissue]["enum"]] = dictNmrPara[strTissue][B0][strPara]
+    return mapPara
+
+def Enum2PD(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get PD map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        Proton density map of the given phantom, relevant to water
+    """
+    return Enum2Para(arrPht, B0, "PD")
+
+def Enum2T1(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get T1 map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        T1 map of the given phantom
+    """
+    return Enum2Para(arrPht, B0, "T1")
+
+def Enum2T2(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get T2 map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        T2 map of the given phantom
+    """
+    return Enum2Para(arrPht, B0, "T2")
+
+def Enum2T2s(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get T2* map of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        T2* map of the given phantom
+    """
+    return Enum2Para(arrPht, B0, "T2s")
+
+def Enum2Adc(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get Apparent Diffusion Coefficient (ADC) map (in `m^2/s`) of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        ADC map of the given phantom
+    """
+    return Enum2Para(arrPht, B0, "ADC")
+
+def Enum2Om(arrPht:NDArray, B0:str|int|float) -> NDArray:
+    """
+    get off-resonance map (in `rad/s`) of a phantom generated by `genPhant()`
+    
+    Args:
+        arrPht: phantom
+        B0: field strength in Tesla
+        
+    Returns:
+        off-resonance map of the given phantom
+    """
+    return Enum2Para(arrPht, B0, "Om")

mrphantom-2.2.1/mrphantom_src/__init__.py

@@ -0,0 +1,7 @@
+from . import utility
+
+with open("test/nmr_para.xml") as f:
+    dictNmrPara = utility.xml2dict(f)
+lstTissue = list(dictNmrPara.keys())
+
+from .Function import genPhant, genPhMap, genB0Map, genCsm, genAmp, genResAmp, genCarAmp, Enum2Para, Enum2PD, Enum2T1, Enum2T2, Enum2Adc, Enum2Om, initSS_bSSFP, initSS_FLASH, Enum2SS, Enum2T2s

{mrphantom-2.2.0 → mrphantom-2.2.1}/mrphantom_src/ext/main.cpp

@@ -6,11 +6,11 @@
 #include <cstring>
 #include <slime.h>
 
-bool inline checkNarg(int64_t lNarg, int64_t lNargExp)
+bool inline checkNarg(int64_t nArg, int64_t nArgExp)
 {
-    if (lNarg != lNargExp)
+    if (nArg != nArgExp)
     {
-        printf("wrong num. of arg, narg=%ld, %ld expected\n", lNarg, lNargExp);
+        printf("wrong num. of arg, narg=%ld, %ld expected\n", nArg, nArgExp);
         abort();
         return false;
     }
@@ -19,34 +19,36 @@ bool inline checkNarg(int64_t lNarg, int64_t lNargExp)
 
 static PyObject* genPhant_py(PyObject* self, PyObject* const* args, Py_ssize_t nargs)
 {
-    checkNarg(nargs,4);
+    checkNarg(nargs,6);
     int64_t nAx = PyLong_AsLongLong(args[0]);
-    int64_t nPix = PyLong_AsLongLong(args[1]);
-    double ampRes = PyFloat_AsDouble(args[2]);
-    double ampCar = PyFloat_AsDouble(args[3]);
+    int64_t nZ = nAx==3 ? PyLong_AsLongLong(args[1]) : 1;
+    int64_t nY = PyLong_AsLongLong(args[2]);
+    int64_t nX = PyLong_AsLongLong(args[3]);
+    double ampRes = PyFloat_AsDouble(args[4]);
+    double ampCar = PyFloat_AsDouble(args[5]);
 
     // Generate into std::vector
-    std::vector<uint8_t> vu8Phant;
-    genPhant(nAx, nPix, ampRes, ampCar, &vu8Phant);
+    std::vector<uint8_t> vu8Phant(nZ*nY*nX, 0);
+    genPhant(nAx, nZ, nY, nX, ampRes, ampCar, &vu8Phant);
 
     // convert vector to numpy array
     PyObject* pPyObj_Arr;
     {
-        npy_intp aDims[] = {nPix, nPix, nPix};
-        pPyObj_Arr = PyArray_ZEROS(nAx, aDims, NPY_UINT8, 0);
+        npy_intp aDims[] = {nZ, nY, nX};
+        pPyObj_Arr = PyArray_ZEROS(nAx, aDims+3-nAx, NPY_UINT8, 0);
     }
 
     // fill the data in
     std::memcpy(PyArray_DATA((PyArrayObject*)pPyObj_Arr),
                 vu8Phant.data(),
                 vu8Phant.size() * sizeof(uint8_t));
-
+    
     return pPyObj_Arr;
 }
 
 static PyMethodDef aMeth[] =
 {
-    {"genPhant", (PyCFunction)genPhant_py, METH_FASTCALL, "genPhant(nAx, nPix, ampRes, ampCar) -> np.ndarray[uint8]"},
+    {"genPhant", (PyCFunction)genPhant_py, METH_FASTCALL, "genPhant(nAx, nZ, nY, nX, ampRes, ampCar) -> np.ndarray[uint8]"},
     {NULL, NULL, 0, NULL}
 };
 

{mrphantom-2.2.0 → mrphantom-2.2.1}/mrphantom_src/ext/slime.cpp

@@ -1,3 +1,4 @@
+#include <cstdio>
 #include <vector>
 #include <cstdint>
 #include <cmath>
@@ -12,8 +13,7 @@ enum Tissue : uint8_t
     Fat = 1,
     Myo = 2,
     Blood = 3,
-    Fill = 4, // we fill the remaining with skeletal mussles
-    Vessel = 5,
+    Liver = 4,
 };
 
 bool isInsideEllipsoid
@@ -39,48 +39,45 @@ bool isInsideEllipsoid
 
 bool genPhant
 (
-    int64_t lNAx, int64_t lNPix,
-    double dResAmp, double dCarAmp,
+    int64_t nAx, int64_t nZ, int64_t nY, int64_t nX,
+    double ampRes, double ampCar,
     std::vector<uint8_t>* voSlime
 )
 {
-    const double dNPix = (double)lNPix;
-    int64_t lNPix_Flat = 0;
-    if (lNAx==2) lNPix_Flat = lNPix*lNPix;
-    else if (lNAx==3)lNPix_Flat = lNPix*lNPix*lNPix;
-    else throw std::runtime_error("lNAx != 2 && lNAx != 3");
-
-    voSlime->assign((size_t)(lNPix_Flat), (uint8_t)(Tissue::Air));
+    size_t nPixSum = nZ*nY*nX;
+    voSlime->resize(nPixSum);
+    voSlime->assign(nPixSum, Tissue::Air);
 
     // shape parameter; r: radius, c: center
-    const double dFatOt_rY = dNPix*400e-3 + dNPix*dResAmp;
-    const double dFatOt_rX = dNPix*400e-3 - 5e-1*dNPix*dResAmp;
-    const double dFatOt_rZ = dNPix*480e-3;
+    const double dFatOt_rY = nY*400e-3 + nY*ampRes;
+    const double dFatOt_rX = nX*400e-3 - 5e-1*nX*ampRes;
+    const double dFatOt_rZ = nZ*480e-3;
 
-    const double dFatIn_rY = dNPix*380e-3 + dNPix*dResAmp;
-    const double dFatIn_rX = dNPix*380e-3 - 5e-1*dNPix*dResAmp;
-    const double dFatIn_rZ = dNPix*450e-3;
+    const double dFatIn_rY = nY*380e-3 + nY*ampRes;
+    const double dFatIn_rX = nX*380e-3 - 5e-1*nX*ampRes;
+    const double dFatIn_rZ = nZ*450e-3;
 
-    const double dMyoOt_rY = dNPix*100e-3 + dNPix*dCarAmp;
-    const double dMyoOt_rX = dNPix*120e-3 + dNPix*dCarAmp;
-    const double dMyoOt_rZ = dMyoOt_rY;
+    const double dMyoOt_rY = nY*100e-3 + nY*ampCar;
+    const double dMyoOt_rX = nX*120e-3 + nX*ampCar;
+    const double dMyoOt_rZ = nZ*100e-3 + nZ*ampCar;;
 
-    const double dMyoIn_rY = dNPix*60e-3 + dNPix*(2*dCarAmp);
-    const double dMyoIn_rX = dNPix*60e-3 + dNPix*(2*dCarAmp);
-    const double dMyoIn_rZ = dMyoIn_rY;
+    const double dMyoIn_rY = nY*60e-3 + nY*(2*ampCar);
+    const double dMyoIn_rX = nX*60e-3 + nX*(2*ampCar);
+    const double dMyoIn_rZ = nZ*60e-3 + nZ*(2*ampCar);;
 
     // Centers are at (0,0,0) in your centered coordinate system,
     const double dFat_cx = 0e0, dFat_cy = 0e0, dFat_cz = 0e0;
     const double dMyoOt_cx = 0e0, dMyoOt_cy = 0e0, dMyoOt_cz = 0e0;
-    const double dMyoIn_cx = -dNPix*20e-3, dMyoIn_cy = 0e0, dMyoIn_cz = 0e0;
+    const double dMyoIn_cx = -nX*20e-3, dMyoIn_cy = 0e0, dMyoIn_cz = 0e0;
 
-    /* generate phantom given by `dResAmp` and `dCarAmp` here */
+    /* generate phantom given by `ampRes` and `ampCar` here */
     #pragma omp parallel for schedule(static)
-    for (int64_t i = 0; i < lNPix_Flat; ++i)
+    for (int64_t i = 0; i < nPixSum; ++i)
     {
-        const int64_t x = i % lNPix - lNPix/2;
-        const int64_t y = (i / lNPix) % lNPix - lNPix/2;
-        const int64_t z = (lNAx == 3) ? (i / (lNPix*lNPix) - lNPix/2) : 0;
+        // derive coordinates
+        const int64_t x = i%nX - nX/2;
+        const int64_t y = (i/nX)%nY - nY/2;
+        const int64_t z = (nAx==3) ? (i/(nY*nX) - nZ/2) : 0;
 
         // decide what tissue current pixel is
         if (!isInsideEllipsoid(x,y,z, dFat_cx,dFat_cy,dFat_cz, dFatOt_rX,dFatOt_rY,dFatOt_rZ))
@@ -96,9 +93,9 @@ bool genPhant
         }
         
         // vessel balls
-        #define V_HIT(cx,cy,cz,div) isInsideEllipsoid(x,y,z, ((cx)*dNPix), ((cy)*dNPix), ((cz)*dNPix), (dFatIn_rX/(div)), (dFatIn_rY/(div)), (dFatIn_rZ/(div)))
+        #define V_HIT(cx,cy,cz,div) isInsideEllipsoid(x,y,z, ((cx)*nX), ((cy)*nY), ((cz)*nZ), (dFatIn_rX/(div)), (dFatIn_rY/(div)), (dFatIn_rZ/(div)))
 
-        // 48 “random” vessels (cx,cy,cz in dNPix fractions; div in ~[18..44])
+        // 48 “random” vessels (cx,cy,cz in nX,nY,nZ fractions; div in ~[18..44])
         #define VLIST \
             /* 5 on XY plane (z = 0) — slightly farther from heart */ \
             V_HIT( 0.18,  0.09,  0.00, 12) || \
@@ -128,16 +125,16 @@ bool genPhant
             V_HIT( 0.14, -0.14, -0.13, 16) || /* + - - */ \
             V_HIT(-0.15, -0.14, -0.13, 16)    /* - - - */
 
-        if ( VLIST )
+        if (VLIST)
         {
-            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Vessel;
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Fat;
             continue;
         }
         // vessel balls (end)
 
         if (!isInsideEllipsoid(x,y,z, dMyoOt_cx,dMyoOt_cy,dMyoOt_cz, dMyoOt_rX,dMyoOt_rY,dMyoOt_rZ))
         {
-            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Fill;
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Liver;
             continue;
         }
 

{mrphantom-2.2.0 → mrphantom-2.2.1}/mrphantom_src/ext/slime.h

@@ -5,7 +5,7 @@
 
 extern bool genPhant
 (
-    int64_t lNDim, int64_t lNPix,
-    double dResAmp, double dCarAmp,
+    int64_t nAx, int64_t nZ, int64_t nY, int64_t nX,
+    double ampRes, double ampCar,
     std::vector<uint8_t>* voSlime
 );

mrphantom-2.2.1/mrphantom_src/nmr_para.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<root>
+    <air enum="0">
+        <B0_0T55 PD="0.00" T1="inf" T2="1e-6" T2s="1e-6" ADC="0.0" Om="0e-6"/>
+        <B0_1T5 PD="0.00" T1="inf" T2="1e-6" T2s="1e-6" ADC="0.0" Om="0e-6"/>
+        <B0_3T PD="0.00" T1="inf" T2="1e-6" T2s="1e-6" ADC="0.0" Om="0e-6"/>
+        <B0_5T PD="0.00" T1="inf" T2="1e-6" T2s="1e-6" ADC="0.0" Om="0e-6"/>
+        <B0_9T4 PD="0.00" T1="inf" T2="1e-6" T2s="1e-6" ADC="0.0" Om="0e-6"/>
+    </air>
+
+    <fat enum="1">
+        <B0_0T55 PD="0.95" T1="280e-3" T2="100e-3" T2s="70e-3" ADC="0.15e-9" Om="-515.01"/>
+        <B0_1T5 PD="0.95" T1="343e-3" T2="58e-3" T2s="50e-3" ADC="0.15e-9" Om="-1404.57"/>
+        <B0_3T PD="0.95" T1="382e-3" T2="68e-3" T2s="35e-3" ADC="0.15e-9" Om="-2809.15"/>
+        <B0_5T PD="0.95" T1="450e-3" T2="60e-3" T2s="25e-3" ADC="0.15e-9" Om="-4681.92"/>
+        <B0_9T4 PD="0.95" T1="500e-3" T2="50e-3" T2s="15e-3" ADC="0.15e-9" Om="-8802.00"/>
+    </fat>
+
+    <myo enum="2">
+        <B0_0T55 PD="0.80" T1="700e-3" T2="60e-3" T2s="50e-3" ADC="1.55e-9" Om="0e-6"/>
+        <B0_1T5 PD="0.80" T1="1008e-3" T2="44e-3" T2s="33e-3" ADC="1.55e-9" Om="0e-6"/>
+        <B0_3T PD="0.80" T1="1220e-3" T2="47e-3" T2s="22e-3" ADC="1.55e-9" Om="0e-6"/>
+        <B0_5T PD="0.80" T1="1450e-3" T2="35e-3" T2s="15e-3" ADC="1.55e-9" Om="0e-6"/>
+        <B0_9T4 PD="0.80" T1="1800e-3" T2="20e-3" T2s="8e-3" ADC="1.55e-9" Om="0e-6"/>
+    </myo>
+
+    <blood enum="3">
+        <B0_0T55 PD="0.95" T1="1120e-3" T2="260e-3" T2s="80e-3" ADC="2.10e-9" Om="0e-6"/>
+        <B0_1T5 PD="0.95" T1="1441e-3" T2="290e-3" T2s="55e-3" ADC="2.10e-9" Om="0e-6"/>
+        <B0_3T PD="0.95" T1="1932e-3" T2="275e-3" T2s="30e-3" ADC="2.10e-9" Om="0e-6"/>
+        <B0_5T PD="0.95" T1="2100e-3" T2="90e-3" T2s="18e-3" ADC="2.10e-9" Om="0e-6"/>
+        <B0_9T4 PD="0.95" T1="2500e-3" T2="40e-3" T2s="10e-3" ADC="2.10e-9" Om="0e-6"/>
+    </blood>
+
+    <liver enum="4">
+        <B0_0T55 PD="0.90" T1="450e-3" T2="55e-3" T2s="45e-3" ADC="1.15e-9" Om="0e-6"/>
+        <B0_1T5 PD="0.90" T1="576e-3" T2="46e-3" T2s="30e-3" ADC="1.15e-9" Om="0e-6"/>
+        <B0_3T PD="0.90" T1="809e-3" T2="34e-3" T2s="18e-3" ADC="1.15e-9" Om="0e-6"/>
+        <B0_5T PD="0.90" T1="1000e-3" T2="34e-3" T2s="10e-3" ADC="1.15e-9" Om="0e-6"/>
+        <B0_9T4 PD="0.90" T1="1200e-3" T2="25e-3" T2s="5e-3" ADC="1.15e-9" Om="0e-6"/>
+    </liver>
+</root>

mrphantom-2.2.1/mrphantom_src/utility.py

@@ -0,0 +1,12 @@
+import xml.etree.ElementTree as ET
+
+def ele2dict(element):
+    result = {
+        key: int(value) if key=="enum" else float(value)
+        for key, value in element.attrib.items()
+    }
+    for child in element:
+        result[child.tag] = ele2dict(child)
+    return result
+
+xml2dict = lambda fXml: ele2dict(ET.parse(fXml).getroot())

{mrphantom-2.2.0 → mrphantom-2.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MRPhantom"
-version = "2.2.0"
+version = "2.2.1"
 dependencies = ["numpy", "scipy"]
 
 description = "Volumetric dynamic MRI Phantom of a Slime with respiratory and cardiac motion, and M0, phase, T1, T2, B0, coil sensitivity maps, boosted by a parallel C-API Backend."

mrphantom-2.2.1/test/test.py

@@ -0,0 +1,15 @@
+import xml.etree.ElementTree as ET
+
+def ele2dict(element):
+    result = {
+        key: float(value)
+        for key, value in element.attrib.items()
+    }
+    for child in element:
+        result[child.tag] = ele2dict(child)
+    return result
+
+xml2dict = lambda fXml: ele2dict(ET.parse(fXml).getroot())
+
+with open("test/nmr_para.xml") as f:
+    dictNmrPara = xml2dict(f)

mrphantom-2.2.1/test/test_Simple.py

@@ -0,0 +1,22 @@
+from numpy import *
+from matplotlib.pyplot import *
+import mrphantom as mpt
+from scipy.ndimage import zoom
+
+# 2D
+nPix = 256
+arrPhant = mpt.genPhant((nPix,nPix//4))
+mpt.initSS_bSSFP(1.5)
+arrM0 = mpt.Enum2SS(arrPhant)*mpt.genPhMap(arrPhant.shape)
+
+arrM0 = zoom(arrM0, (1,4))
+
+figure(figsize=(6,3), dpi=150)
+subplot(121)
+imshow(abs(arrM0), cmap="gray"); colorbar()
+title("Magnitude")
+subplot(122)
+imshow(angle(arrM0), cmap="hsv", vmin=-pi, vmax=pi); colorbar()
+title("Phase")
+tight_layout()
+show()

mrphantom-2.2.0/mrphantom_src/Function.py

@@ -1,436 +0,0 @@
-from . import ext
-from numpy import *
-from numpy.typing import NDArray
-from enum import Enum
-from scipy.ndimage import gaussian_filter
-
-class Tissue(Enum):
-    Air = 0
-    Fat = 1
-    Myo = 2 # Myocadium
-    Blood = 3
-    Liver = 4
-    Vessel = 5
-    NTissue = 6
-
-def genPhant(nAx:int=2, nPix:int=256, ampRes:float=0, ampCar:float=0) -> NDArray: # call C++ backend to generate a phantom
-    """
-    generate a phantom in Enum type
-    
-    Args:
-        nAx: number of dimensions
-        nPix: number of pixels
-        ampRes: respiratory motion amplitude
-        ampCar: cardiac motion amplitude
-        
-    Returns:
-        NDArray contains elements in `Tissue` enum type
-    """
-    return ext.genPhant(nAx, nPix, ampRes, ampCar)
-
-def genPhMap(nAx:int=2, nPix:int=256, mean:int|float|None=None, std:int|float=pi/16) -> NDArray:
-    """
-    generate random phase map
-    
-    Args:
-        nAx: number of dimensions
-        nPix: number of pixels
-        mean: mean of the noise
-        std: std of the noise
-        
-    Returns:
-        smooth complex noise with unity magnitude
-    """
-    if mean is None: mean = random.uniform(-pi,pi)
-    mapPh = random.uniform(-pi, pi, [nPix for _ in range(nAx)])
-    sigma = nPix/4
-    mapPh = gaussian_filter(mapPh, sigma)
-    # normalize
-    mapPh -= mapPh.mean(); mapPh = asarray(mapPh)
-    mapPh /= mapPh.std()
-    mapPh *= std
-    mapPh += mean
-    # convert to rotation factor
-    mapPh = exp(1j*mapPh)
-    mapPh = mapPh/abs(mapPh)
-    return mapPh
-
-def genB0Map(nAx:int=2, nPix:int=256, mean:int|float=0, std:int|float=1e-6*(2*pi*42.58e6*3)) -> NDArray:
-    """
-    generate random B0 map
-    
-    Args:
-        nAx: number of dimensions
-        nPix: number of pixels
-        mean: mean of the noise
-        std: std of the noise
-        
-    Returns:
-        smooth random noise in `rad/s`
-    """
-    mapB0 = random.uniform(-1, 1, [nPix for _ in range(nAx)])
-    sigma = nPix/4
-    mapB0 = gaussian_filter(mapB0, sigma)
-    # normalize
-    mapB0 -= mapB0.mean(); mapB0 = asarray(mapB0)
-    mapB0 /= mapB0.std()
-    mapB0 *= std
-    mapB0 += mean
-    return mapB0
-
-def genCsm(nAx:int=2, nPix:int=256, nCh:int=12, mean:int|float|None=None, std:int|float=pi/16) -> NDArray:
-    """
-    generate random coil sensitivity map
-    
-    Args:
-        nAx: number of dimensions
-        nPix: number of pixels
-        nCh: number of coils
-        mean: mean of the noise
-        std: std of the noise
-        
-    Returns:
-        complex smooth and inhomogeneous map
-    """
-    if mean is None: mean = random.uniform(-pi,pi)
-    mapC = zeros([nCh,*(nPix for _ in range(nAx))], dtype=complex128)
-    arrCoor = meshgrid\
-    (
-        *(linspace(-0.5,0.5,nPix,0) for _ in range(nAx)),
-        indexing="ij"
-    ); arrCoor = array(arrCoor).transpose(*arange(1,nAx+1), 0)
-    arrTht = linspace(0,2*pi,nCh,0)
-    arrCoorCoil = zeros([nCh,nAx], dtype=float64)
-    arrCoorCoil[:,-2:] = 1*array([sin(arrTht), cos(arrTht)]).T
-    if nAx == 3:
-        arrCoorCoil[0::2,0] = 0.2
-        arrCoorCoil[1::2,0] = -0.2
-    for iCh in range(nCh):
-        mapC[iCh] = genPhMap(nAx=nAx, nPix=nPix, mean=mean, std=std)
-        dist = sqrt(sum((arrCoor - arrCoorCoil[iCh])**2, axis=-1))
-        mapC[iCh] *= exp(-dist)
-    return mapC
-
-def genAmp(tScan:int|float, tRes:int|float, cyc:int|float, isRand:bool=True) -> NDArray:
-    """
-    generate amplitude curve
-    
-    Args:
-        tScan: length of the signal in `s`
-        tRes: temporal resolution in `s`
-        cyc: period of the signal in `s`
-        isRand: make the signal have irregular period
-        
-    Returns:
-        generated amplitude
-    """
-    nT = around(tScan/tRes).astype(int)
-
-    if isRand:
-        arrT = sort(random.rand(nT)*tScan)
-        arrAmp = sin(2*pi/cyc*arrT)
-
-        sigma = cyc/tRes/8
-        arrAmp = gaussian_filter(arrAmp, sigma)
-    else:
-        arrT = linspace(0, tScan, nT)
-        arrAmp = sin(2*pi/cyc*arrT)
-
-    return arrAmp
-
-def genResAmp(tScan:int|float, tRes:int|float, cyc:int|float=pi/2) -> NDArray:
-    """
-    generate respiratory amplitude curve
-    
-    Args:
-        tScan: length of the signal in `s`
-        tRes: temporal resolution in `s`
-        cyc: period of the signal in `s`
-        
-    Returns:
-        generated amplitude, approx. -0.02~0.02
-    """
-    return 20e-3*genAmp(tScan, tRes, cyc, 1)
-
-def genCarAmp(tScan:int|float, tRes:int|float, cyc:int|float=1) -> NDArray:
-    """
-    generate cardiac amplitude curve
-    
-    Args:
-        tScan: length of the signal in `s`
-        tRes: temporal resolution in `s`
-        cyc: period of the signal in `s`
-        
-    Returns:
-        generated amplitude, approx. -0.01~0.01
-    """
-    return 10e-3*genAmp(tScan, tRes, cyc, 0)
-
-def Enum2SS(arrPht:NDArray, ampCar:double=0e0, B0:double=5.0, TR:double=None, TE:double=None, FA_deg:double=None, bSSFP:bool=False, mapPh:NDArray=None) -> NDArray:
-    """
-    get steady-state signal map of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        ampCar: cardiac motion amplitude
-        TR: repetition time
-        TE: echo time
-        FA_deg: flip angle in degree
-        bSSFP: True for bSSFP, False for FLASH
-        mapPh: phase map array, can be generated using genPhMap() `NTissue` times
-        
-    Returns:
-        steady state signal map of the given phantom
-    """
-    mapPD = Enum2PD(arrPht)
-    mapT1 = Enum2T1(arrPht, B0)
-    if bSSFP:
-        if TR is None: TR = 5e-3
-        if TE is None: TE = 1e-3
-        if FA_deg is None: FA_deg = 60
-        FA = FA_deg * pi/180
-        mapT2 = Enum2T2(arrPht, B0)
-        E1 = exp(-TR/mapT1)
-        E2 = exp(-TR/mapT2)
-        mapSS = (
-            mapPD
-            * (1-E1)
-            * sqrt(E2)
-            * sin(FA)
-            / (1 - (E1-E2)*cos(FA) - E1*E2)
-        ) + 0j
-    else:
-        if TR is None: TR = 10e-3
-        if TE is None: TE = 1e-3
-        if FA_deg is None: FA_deg = 10
-        FA = FA_deg * pi/180
-        mapT2s = Enum2T2s(arrPht, B0)
-        E1 = exp(-TR/mapT1)
-        E2 = exp(-TE/mapT2s)
-        mapSS = (
-            mapPD
-            *sin(FA)
-            *(1-E1)
-            /(1-cos(FA)*E1)
-            *E2
-        ) + 0j
-    kInFow = 1.5 + max(-ampCar,0)*20
-    mapSS[arrPht==Tissue.Blood.value] *= kInFow
-    mapSS[arrPht==Tissue.Vessel.value] *= kInFow
-    if mapPh is not None:
-        for iTissue in range(Tissue.NTissue.value):
-            mapSS[arrPht==iTissue] *= mapPh[iTissue][arrPht==iTissue]
-    return mapSS
-
-def Enum2PD(arrPht:NDArray) -> NDArray:
-    """
-    get PD map of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        
-    Returns:
-        Proton density map of the given phantom, relevant to water
-    """
-    mapPD = zeros_like(arrPht, dtype=float64)
-    mapPD[arrPht==Tissue.Air.value] = 0
-    mapPD[arrPht==Tissue.Fat.value] = 0.95
-    mapPD[arrPht==Tissue.Myo.value] = 0.80
-    mapPD[arrPht==Tissue.Blood.value] = 0.95
-    mapPD[arrPht==Tissue.Liver.value] = 0.90
-    mapPD[arrPht==Tissue.Vessel.value] = 0.95
-    return mapPD
-
-def Enum2T1(arrPht:NDArray, B0:int|float) -> NDArray:
-    """
-    get T1 map of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        
-    Returns:
-        T1 map of the given phantom
-    """
-    mapT1 = zeros_like(arrPht, dtype=float64)
-    if B0==0.55:
-        mapT1[arrPht==Tissue.Air.value] = inf
-        mapT1[arrPht==Tissue.Fat.value] = 280e-3
-        mapT1[arrPht==Tissue.Myo.value] = 700e-3
-        mapT1[arrPht==Tissue.Blood.value] = 1120e-3
-        mapT1[arrPht==Tissue.Liver.value] = 450e-3
-        mapT1[arrPht==Tissue.Vessel.value] = 1120e-3
-    elif B0==1.5:
-        mapT1[arrPht==Tissue.Air.value] = inf
-        mapT1[arrPht==Tissue.Fat.value] = 350e-3
-        mapT1[arrPht==Tissue.Myo.value] = 1030e-3
-        mapT1[arrPht==Tissue.Blood.value] = 1450e-3
-        mapT1[arrPht==Tissue.Liver.value] = 1580e-3
-        mapT1[arrPht==Tissue.Vessel.value] = 1450e-3
-    elif B0==3.0:
-        mapT1[arrPht==Tissue.Air.value] = inf
-        mapT1[arrPht==Tissue.Fat.value] = 400e-3
-        mapT1[arrPht==Tissue.Myo.value] = 1200e-3
-        mapT1[arrPht==Tissue.Blood.value] = 1800e-3
-        mapT1[arrPht==Tissue.Liver.value] = 800e-3
-        mapT1[arrPht==Tissue.Vessel.value] = 1800e-3
-    elif B0==5.0:
-        mapT1[arrPht==Tissue.Air.value] = inf
-        mapT1[arrPht==Tissue.Fat.value] = 450e-3
-        mapT1[arrPht==Tissue.Myo.value] = 1450e-3
-        mapT1[arrPht==Tissue.Blood.value] = 2100e-3
-        mapT1[arrPht==Tissue.Liver.value] = 1000e-3
-        mapT1[arrPht==Tissue.Vessel.value] = 2100e-3
-    elif B0==9.4:
-        mapT1[arrPht==Tissue.Air.value] = inf
-        mapT1[arrPht==Tissue.Fat.value] = 500e-3
-        mapT1[arrPht==Tissue.Myo.value] = 1800e-3
-        mapT1[arrPht==Tissue.Blood.value] = 2500e-3
-        mapT1[arrPht==Tissue.Liver.value] = 1200e-3
-        mapT1[arrPht==Tissue.Vessel.value] = 2500e-3
-    else:
-        raise RuntimeError(f"B0={B0:.2f} not available.")
-    return mapT1
-
-def Enum2T2(arrPht:NDArray, B0:int|float) -> NDArray:
-    """
-    get T2 map of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        
-    Returns:
-        T2 map of the given phantom
-    """
-    mapT2 = zeros_like(arrPht, dtype=float64)
-    if B0==0.55:
-        mapT2[arrPht==Tissue.Air.value] = 1e-6
-        mapT2[arrPht==Tissue.Fat.value] = 100e-3
-        mapT2[arrPht==Tissue.Myo.value] = 60e-3
-        mapT2[arrPht==Tissue.Blood.value] = 260e-3
-        mapT2[arrPht==Tissue.Liver.value] = 55e-3
-        mapT2[arrPht==Tissue.Vessel.value] = 260e-3
-    elif B0==1.5:
-        mapT2[arrPht==Tissue.Air.value] = 1e-6
-        mapT2[arrPht==Tissue.Fat.value] = 80e-3
-        mapT2[arrPht==Tissue.Myo.value] = 45e-3
-        mapT2[arrPht==Tissue.Blood.value] = 275e-3
-        mapT2[arrPht==Tissue.Liver.value] = 46e-3
-        mapT2[arrPht==Tissue.Vessel.value] = 275e-3
-    elif B0==3.0:
-        mapT2[arrPht==Tissue.Air.value] = 1e-6
-        mapT2[arrPht==Tissue.Fat.value] = 70e-3
-        mapT2[arrPht==Tissue.Myo.value] = 40e-3
-        mapT2[arrPht==Tissue.Blood.value] = 120e-3
-        mapT2[arrPht==Tissue.Liver.value] = 40e-3
-        mapT2[arrPht==Tissue.Vessel.value] = 120e-3
-    elif B0==5.0:
-        mapT2[arrPht==Tissue.Air.value] = 1e-6
-        mapT2[arrPht==Tissue.Fat.value] = 60e-3
-        mapT2[arrPht==Tissue.Myo.value] = 35e-3
-        mapT2[arrPht==Tissue.Blood.value] = 90e-3
-        mapT2[arrPht==Tissue.Liver.value] = 34e-3
-        mapT2[arrPht==Tissue.Vessel.value] = 90e-3
-    elif B0==9.4:
-        mapT2[arrPht==Tissue.Air.value] = 1e-6
-        mapT2[arrPht==Tissue.Fat.value] = 50e-3
-        mapT2[arrPht==Tissue.Myo.value] = 20e-3
-        mapT2[arrPht==Tissue.Blood.value] = 40e-3
-        mapT2[arrPht==Tissue.Liver.value] = 25e-3
-        mapT2[arrPht==Tissue.Vessel.value] = 40e-3
-    else:
-        raise RuntimeError(f"B0={B0:.2f} not available.")
-    return mapT2
-
-def Enum2T2s(arrPht:NDArray, B0:int|float) -> NDArray:
-    """
-    get T2* map of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        
-    Returns:
-        T2* map of the given phantom
-    """
-    mapT2s = zeros_like(arrPht, dtype=float64)
-    if B0==0.55:
-        mapT2s[arrPht==Tissue.Air.value] = 1e-6
-        mapT2s[arrPht==Tissue.Fat.value] = 70e-3
-        mapT2s[arrPht==Tissue.Myo.value] = 50e-3
-        mapT2s[arrPht==Tissue.Blood.value] = 80e-3
-        mapT2s[arrPht==Tissue.Liver.value] = 45e-3
-        mapT2s[arrPht==Tissue.Vessel.value] = 80e-3
-    elif B0==1.5:
-        mapT2s[arrPht==Tissue.Air.value] = 1e-6
-        mapT2s[arrPht==Tissue.Fat.value] = 50e-3
-        mapT2s[arrPht==Tissue.Myo.value] = 33e-3
-        mapT2s[arrPht==Tissue.Blood.value] = 55e-3
-        mapT2s[arrPht==Tissue.Liver.value] = 30e-3
-        mapT2s[arrPht==Tissue.Vessel.value] = 55e-3
-    elif B0==3.0:
-        mapT2s[arrPht==Tissue.Air.value] = 1e-6
-        mapT2s[arrPht==Tissue.Fat.value] = 35e-3
-        mapT2s[arrPht==Tissue.Myo.value] = 22e-3
-        mapT2s[arrPht==Tissue.Blood.value] = 30e-3
-        mapT2s[arrPht==Tissue.Liver.value] = 18e-3
-        mapT2s[arrPht==Tissue.Vessel.value] = 30e-3
-    elif B0==5.0:
-        mapT2s[arrPht==Tissue.Air.value] = 1e-6
-        mapT2s[arrPht==Tissue.Fat.value] = 25e-3
-        mapT2s[arrPht==Tissue.Myo.value] = 15e-3
-        mapT2s[arrPht==Tissue.Blood.value] = 18e-3
-        mapT2s[arrPht==Tissue.Liver.value] = 10e-3
-        mapT2s[arrPht==Tissue.Vessel.value] = 18e-3
-    elif B0==9.4:
-        mapT2s[arrPht==Tissue.Air.value] = 1e-6
-        mapT2s[arrPht==Tissue.Fat.value] = 15e-3
-        mapT2s[arrPht==Tissue.Myo.value] = 8e-3
-        mapT2s[arrPht==Tissue.Blood.value] = 10e-3
-        mapT2s[arrPht==Tissue.Liver.value] = 5e-3
-        mapT2s[arrPht==Tissue.Vessel.value] = 10e-3
-    else:
-        raise RuntimeError(f"B0={B0:.2f} not available.")
-    return mapT2s
-
-def Enum2Adc(arrPht:NDArray, B0:int|float) -> NDArray:
-    """
-    get Apparent Diffusion Coefficient (ADC) map (in `m^2/s`) of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        B0: field strength in Tesla
-        
-    Returns:
-        ADC map of the given phantom
-    """
-    mapADC = zeros_like(arrPht, dtype=float64)
-    if B0 in [0.55, 1.5, 3.0, 5.0, 9.4]:
-        mapADC[arrPht==Tissue.Air.value] = 0.0
-        mapADC[arrPht==Tissue.Fat.value] = 0.15e-9
-        mapADC[arrPht==Tissue.Myo.value] = 1.55e-9
-        mapADC[arrPht==Tissue.Blood.value] = 2.10e-9
-        mapADC[arrPht==Tissue.Liver.value] = 1.15e-9
-        mapADC[arrPht==Tissue.Vessel.value] = 2.10e-9
-    else:
-        raise RuntimeError(f"B0={B0:.2f} not available.")
-    return mapADC
-
-def Enum2Om(arrPht:NDArray, B0:int|float) -> NDArray:
-    """
-    get off-resonance map (in `rad/s`) of a phantom generated by `genPhant()`
-    
-    Args:
-        arrPht: phantom
-        B0: field strength in Tesla
-        
-    Returns:
-        off-resonance map of the given phantom
-    """
-    mapOm = zeros_like(arrPht, dtype=float64)
-    ppm2om = 1e-6*(2*pi*42.58e6*B0)
-    mapOm[arrPht==Tissue.Air.value] = 0
-    mapOm[arrPht==Tissue.Fat.value] = 3.5*ppm2om
-    mapOm[arrPht==Tissue.Myo.value] = 0
-    mapOm[arrPht==Tissue.Blood.value] = 0
-    mapOm[arrPht==Tissue.Liver.value] = 0
-    mapOm[arrPht==Tissue.Vessel.value] = 0
-    return mapOm

mrphantom-2.2.0/mrphantom_src/__init__.py

@@ -1,5 +0,0 @@
-# from .Type import Part
-# from .Function import genPhan
-# from .Utility import genAmp, genCsm
-
-from .Function import genPhant, genPhMap, genB0Map, genCsm, genAmp, genResAmp, genCarAmp, Enum2PD, Enum2T1, Enum2T2, Enum2Adc, Enum2Om, Enum2SS, Enum2T2s, Tissue