MRPhantom 0.0.0__tar.gz

mrphantom-0.0.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Rui Luo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

mrphantom-0.0.0/MANIFEST.in

@@ -0,0 +1 @@
+global-include *.py *.c *.cpp *.h *.hpp

mrphantom-0.0.0/MRPhantom.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: MRPhantom
+Version: 0.0.0
+Summary: MRI Phantom of a Slime with Repiratory and Cardiac Motion, and M0, Phase, T1, T2, B0 maps, Boosted by a C-API Backend.
+Author-email: Ryan <ryan_shanghaitech@proton.me>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/RyanShanghaitech/Slime
+Project-URL: Examples, https://github.com/RyanShanghaitech/Slime/tree/main/example
+Keywords: MRI,Phantom,Motion,Quantitative
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# MRI Digital Phantom
+A quantitative phantom of a slime with cardiac and respiratory motion.

mrphantom-0.0.0/MRPhantom.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+./slime_src/ext/main.cpp
+./slime_src/ext/slime.cpp
+MRPhantom.egg-info/PKG-INFO
+MRPhantom.egg-info/SOURCES.txt
+MRPhantom.egg-info/dependency_links.txt
+MRPhantom.egg-info/requires.txt
+MRPhantom.egg-info/top_level.txt
+example/Example_2D.py
+example/Example_3D.py
+example/Example_Simple.py
+example/Example_Utility.py
+slime_src/Function.py
+slime_src/__init__.py
+slime_src/ext/main.cpp
+slime_src/ext/slime.cpp
+slime_src/ext/slime.h

mrphantom-0.0.0/MRPhantom.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mrphantom-0.0.0/MRPhantom.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

mrphantom-0.0.0/MRPhantom.egg-info/top_level.txt

@@ -0,0 +1 @@
+slime

mrphantom-0.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: MRPhantom
+Version: 0.0.0
+Summary: MRI Phantom of a Slime with Repiratory and Cardiac Motion, and M0, Phase, T1, T2, B0 maps, Boosted by a C-API Backend.
+Author-email: Ryan <ryan_shanghaitech@proton.me>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/RyanShanghaitech/Slime
+Project-URL: Examples, https://github.com/RyanShanghaitech/Slime/tree/main/example
+Keywords: MRI,Phantom,Motion,Quantitative
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Dynamic: license-file
+
+# MRI Digital Phantom
+A quantitative phantom of a slime with cardiac and respiratory motion.

mrphantom-0.0.0/README.md

@@ -0,0 +1,2 @@
+# MRI Digital Phantom
+A quantitative phantom of a slime with cardiac and respiratory motion.

mrphantom-0.0.0/example/Example_2D.py

@@ -0,0 +1,37 @@
+from numpy import *
+from matplotlib.pyplot import *
+import slime
+from time import time
+
+tScan = 10
+tRes = 10e-3
+nT = int(tScan/tRes)
+nPix = 256
+
+cycRes = pi/2
+cycCar = 1
+arrAmpRes = 20e-3*slime.genAmp(tScan, tRes, cycRes, 1)
+arrAmpCar = 10e-3*slime.genAmp(tScan, tRes, cycCar, 0)
+
+fig = figure()
+ax = fig.add_subplot(211)
+ax.plot(arrAmpRes, ".-")
+ax.set_title("Respiratory")
+ax = fig.add_subplot(212)
+ax.plot(arrAmpCar, ".-")
+ax.set_title("Cardiac")
+
+fig = figure(figsize=(6,6), dpi=120)
+ax = fig.add_subplot(111)
+axim = ax.imshow(zeros([nPix,nPix]), cmap='gray', vmin=0, vmax=1)
+
+while 1:
+    for iT in range(nT):
+        arrPhant = slime.genPhant(2, nPix, arrAmpRes[iT], arrAmpCar[iT])
+        arrM0 = slime.Enum2M0(arrPhant, arrAmpCar[iT])
+        
+        axim.set_data(arrM0)
+        ax.set_title(f"time: {iT*tRes:.2f}s")
+        draw()
+        pause(tRes/10)
+        # pause(1e-2)

mrphantom-0.0.0/example/Example_3D.py

@@ -0,0 +1,42 @@
+from numpy import *
+from matplotlib.pyplot import *
+import slime
+from time import time
+
+tScan = 10
+tRes = 10e-3
+nT = int(tScan/tRes)
+nPix = 256
+
+cycRes = pi/2
+cycCar = 1
+arrAmpRes = 20e-3*slime.genAmp(tScan, tRes, cycRes, 1)
+arrAmpCar = 10e-3*slime.genAmp(tScan, tRes, cycCar, 0)
+
+fig = figure()
+ax = fig.add_subplot(211)
+ax.plot(arrAmpRes, ".-")
+ax.set_title("Respiratory")
+ax = fig.add_subplot(212)
+ax.plot(arrAmpCar, ".-")
+ax.set_title("Cardiac")
+
+fig = figure(figsize=(9,3), dpi=120)
+ax1 = fig.add_subplot(131)
+axim1 = ax1.imshow(zeros([nPix,nPix]), cmap='gray', vmin=0, vmax=1)
+ax2 = fig.add_subplot(132)
+axim2 = ax2.imshow(zeros([nPix,nPix]), cmap='gray', vmin=0, vmax=1)
+ax3 = fig.add_subplot(133)
+axim3 = ax3.imshow(zeros([nPix,nPix]), cmap='gray', vmin=0, vmax=1)
+
+while 1:
+    for iT in range(0,nT,10):
+        arrPhant = slime.genPhant(3, nPix, arrAmpRes[iT], arrAmpCar[iT])
+        arrM0 = slime.Enum2M0(arrPhant, arrAmpCar[iT])
+        
+        axim1.set_data(arrM0[nPix//2,:,:])
+        axim2.set_data(arrM0[:,nPix//2,:])
+        axim3.set_data(arrM0[:,:,nPix//2])
+        ax2.set_title(f"time: {iT*tRes:.2f}s")
+        draw()
+        pause(tRes/10)

mrphantom-0.0.0/example/Example_Simple.py

@@ -0,0 +1,63 @@
+from numpy import *
+from matplotlib.pyplot import *
+import slime
+
+# 2D
+nPix = 4096
+arrPhant = slime.genPhant(nAx=2, nPix=nPix)
+arrM0 = slime.Enum2M0(arrPhant)
+
+arrM0Abs = abs(arrM0)
+figure(figsize=(3,3), dpi=120)
+imshow(arrM0Abs, cmap="gray"); colorbar()
+draw(); pause(0.5)
+
+# 3D
+nPix = 256
+arrPhant = slime.genPhant(nAx=3, nPix=nPix)
+arrM0 = slime.Enum2M0(arrPhant)
+
+arrM0Abs = abs(arrM0)
+figure(figsize=(9,3), dpi=120)
+subplot(131)
+imshow(arrM0Abs[nPix//2,:,:], cmap="gray"); colorbar()
+subplot(132)
+imshow(arrM0Abs[:,nPix//2,:], cmap="gray"); colorbar()
+subplot(133)
+imshow(arrM0Abs[:,:,nPix//2], cmap="gray"); colorbar()
+draw(); pause(0.5)
+
+# --- NEW FIGURE: animated 3D slice viewer (does not modify the static figure) ---
+V = arrM0Abs  # already computed above (shape: [nPix,nPix,nPix])
+
+vmin = V.min()
+vmax = V.max()
+
+figA = figure(figsize=(9, 3), dpi=120)
+ax1 = figA.add_subplot(131)
+ax2 = figA.add_subplot(132)
+ax3 = figA.add_subplot(133)
+
+k0 = nPix // 2
+im1 = ax1.imshow(V[k0, :, :], cmap="gray", vmin=vmin, vmax=vmax, origin="lower")
+im2 = ax2.imshow(V[:, k0, :], cmap="gray", vmin=vmin, vmax=vmax, origin="lower")
+im3 = ax3.imshow(V[:, :, k0], cmap="gray", vmin=vmin, vmax=vmax, origin="lower")
+
+ax1.set_title(f"axial z={k0}")
+ax2.set_title(f"coronal y={k0}")
+ax3.set_title(f"sagittal x={k0}")
+
+tight_layout()
+draw()
+pause(0.25)
+
+pause_dt = 1e-6  # seconds; increase if too fast
+for k in list(range(nPix)) + list(range(nPix-2, 0, -1)):
+    im1.set_data(V[k, :, :]); ax1.set_title(f"axial z={k}")
+    im2.set_data(V[:, k, :]); ax2.set_title(f"coronal y={k}")
+    im3.set_data(V[:, :, k]); ax3.set_title(f"sagittal x={k}")
+    figA.canvas.draw_idle()
+    pause(pause_dt)
+# --- end block ---
+
+show()

mrphantom-0.0.0/example/Example_Utility.py

@@ -0,0 +1,61 @@
+import slime
+from numpy import *
+from matplotlib.pyplot import *
+from matplotlib.colors import ListedColormap
+
+nDim = 3
+nPix = 128
+
+mapPh = slime.genPhMap(nDim, nPix, std=pi/16)
+mapB0 = slime.genB0Map(nDim, nPix, std=1) # unit: ppm
+
+arrPhant = slime.genPhant(nDim, nPix)
+mapM0 = slime.Enum2M0(arrPhant)
+mapT1 = slime.Enum2T1(arrPhant)
+mapT2 = slime.Enum2T2(arrPhant)
+mapOm = slime.Enum2Om(arrPhant)
+mapC = slime.genCsm(nDim, nPix, mean=0, std=pi/16)
+
+# plot
+cmT1 = ListedColormap(loadtxt("./Resource/lipari.csv"), name="T1")
+cmT2 = ListedColormap(loadtxt("./Resource/navia.csv"), name="T2")
+
+figure(figsize=(9,5), dpi=120)
+subplot(121)
+imshow(angle(mapPh[:,nPix//2,:]), cmap="hsv", vmin=-pi, vmax=pi)
+colorbar()
+title("phase map")
+subplot(122)
+imshow(mapB0[:,nPix//2,:], vmin=-3, vmax=3)
+colorbar().set_label("ppm")
+title("B0 map")
+
+mapM0Abs = abs(mapM0)
+figure(figsize=(9,9), dpi=120)
+subplot(221)
+imshow(mapM0Abs[:,nPix//2,:], cmap="gray"); colorbar(); title("M0 map")
+subplot(222)
+imshow(mapT1[:,nPix//2,:]*1000, cmap=cmT1); colorbar().set_label("ms"); title("T1 map")
+subplot(223)
+imshow(mapT2[:,nPix//2,:]*1000, cmap=cmT2); colorbar().set_label("ms"); title("T2 map")
+subplot(224)
+imshow(mapOm[:,nPix//2,:]); colorbar(); title("Om map")
+
+mapCsmAbs = abs(mapC)
+mapCsmAng = angle(mapC)
+fig = figure(figsize=(9,9), dpi=120)
+gs = fig.add_gridspec(2,1)
+
+subfig = fig.add_subfigure(gs[0])
+for iFig in range(3*4):
+    ax = subfig.add_subplot(3,4,iFig+1)
+    axim = ax.imshow(mapCsmAbs[iFig,nPix-2,:,:], cmap="gray", vmin=0, vmax=1)
+    subfig.colorbar(axim)
+
+subfig = fig.add_subfigure(gs[1])
+for iFig in range(3*4):
+    ax = subfig.add_subplot(3,4,iFig+1)
+    axim = ax.imshow(mapCsmAng[iFig,nPix-2,:,:], cmap="hsv", vmin=-pi, vmax=pi)
+    subfig.colorbar(axim)
+
+show()

mrphantom-0.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "MRPhantom"
+version = "0.0.0"
+dependencies = ["numpy"]
+
+description = "MRI Phantom of a Slime with Repiratory and Cardiac Motion, and M0, Phase, T1, T2, B0 maps, Boosted by a C-API Backend."
+keywords = ["MRI", "Phantom", "Motion", "Quantitative"]
+authors = [{name = "Ryan", email = "ryan_shanghaitech@proton.me"}]
+
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+
+[project.urls]
+Repository = "https://github.com/RyanShanghaitech/Slime"
+Examples = "https://github.com/RyanShanghaitech/Slime/tree/main/example"

mrphantom-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mrphantom-0.0.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, Extension
+import numpy
+
+_sources = \
+[
+    './slime_src/ext/main.cpp',
+    './slime_src/ext/slime.cpp',
+]
+
+modExt = Extension\
+(
+    "slime.ext", 
+    sources = _sources,
+    include_dirs = ["./slime_src/ext/", numpy.get_include()],
+    language = 'c++',
+    extra_compile_args = ["-O3", "-fopenmp"],
+    extra_link_args = ["-fopenmp"],
+)
+
+_packages = \
+[
+    "slime", 
+    "slime.ext",
+]
+
+_package_dir = \
+{
+    "slime":"./slime_src/", 
+    "slime.ext":"./slime_src/ext/",
+}
+
+setup\
+(
+    name = 'slime',
+    ext_modules = [modExt],
+    packages = _packages,
+    package_dir = _package_dir,
+    include_package_data = True
+)

mrphantom-0.0.0/slime_src/Function.py

@@ -0,0 +1,144 @@
+import slime.ext as ext
+from numpy import *
+from enum import Enum
+from scipy.ndimage import gaussian_filter
+
+class Tissue(Enum):
+    Air = 0
+    Fat = 1
+    Myo = 2
+    Blood = 3
+    Fill = 4
+    Vessel = 5
+
+def genPhant(nAx:int=2, nPix:int=256, ampRes:float=0, ampCar:float=0) -> ndarray: # call C++ backend to generate a phantom
+    '''
+    nAx: number of dimensions
+    nPix: number of pixels
+    ampRes: respiratory motion amplitude
+    ampCar: cardiac motion amplitude
+    '''
+    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:
+    '''
+    # return
+    smooth complex rotation factor
+    '''
+    if mean == 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:
+    '''
+    # return
+    smooth random number
+    '''
+    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:
+    if mean == 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:
+    '''
+    # parameter
+    `tScan`: how many seconds this waveform contains
+    `tRes`: how many seconds per frame
+    `cyc`: cycle of desired signal in second
+    `isRand`: whether to randomize the waveform
+    '''
+    nT = int(tScan/tRes)
+
+    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:
+    return 20e-3*genAmp(tScan, tRes, cyc, 1)
+
+def genCarAmp(tScan:int|float, tRes:int|float, cyc:int|float=1) -> ndarray:
+    return 10e-3*genAmp(tScan, tRes, cyc, 0)
+
+def Enum2M0(arrPhan:ndarray, ampCar:double=0e0) -> ndarray:
+    mapM0 = zeros_like(arrPhan, dtype=float64)
+    mapM0[arrPhan==Tissue.Air.value] = 0 # random.randn(sum(arrPhan==Part.Air.value))*1e-3
+    mapM0[arrPhan==Tissue.Fat.value] = 1.0
+    mapM0[arrPhan==Tissue.Myo.value] = 0.2
+    mapM0[arrPhan==Tissue.Blood.value] = 0.8
+    mapM0[arrPhan==Tissue.Fill.value] = 0.5
+    mapM0[arrPhan==Tissue.Vessel.value] = 0.8 - ampCar*10
+    return mapM0
+
+def Enum2T1(arrPhan:ndarray) -> ndarray:
+    mapT1 = zeros_like(arrPhan, dtype=float64)
+    mapT1[arrPhan==Tissue.Air.value] = inf # 10000e-3 #random.uniform(1e-3, 10000e-3, sum(arrPhan==Part.Air.value))
+    mapT1[arrPhan==Tissue.Fat.value] = 350e-3
+    mapT1[arrPhan==Tissue.Myo.value] = 1300e-3
+    mapT1[arrPhan==Tissue.Blood.value] = 1500e-3
+    mapT1[arrPhan==Tissue.Fill.value] = 1600e-3
+    mapT1[arrPhan==Tissue.Vessel.value] = 1500e-3
+    return mapT1
+
+def Enum2T2(arrPhan:ndarray) -> ndarray:
+    mapT2 = zeros_like(arrPhan, dtype=float64)
+    mapT2[arrPhan==Tissue.Air.value] = 1e-6 # random.uniform(1e-3, 1000e-3, sum(arrPhan==Part.Air.value))
+    mapT2[arrPhan==Tissue.Fat.value] = 75e-3
+    mapT2[arrPhan==Tissue.Myo.value] = 50e-3
+    mapT2[arrPhan==Tissue.Blood.value] = 225e-3
+    mapT2[arrPhan==Tissue.Fill.value] = 40e-3
+    mapT2[arrPhan==Tissue.Vessel.value] = 225e-3
+    return mapT2
+
+def Enum2Om(arrPhan:ndarray, B0:int|float=3) -> ndarray:
+    mapOm = zeros_like(arrPhan, dtype=float64)
+    ppm2om = 1e-6*(2*pi*42.58e6*B0)
+    mapOm[arrPhan==Tissue.Air.value] = 0 # random.uniform(1e-3, 10e-3, sum(arrPhan==Part.Air.value))*ppm2om
+    mapOm[arrPhan==Tissue.Fat.value] = 3.5*ppm2om
+    mapOm[arrPhan==Tissue.Myo.value] = 0
+    mapOm[arrPhan==Tissue.Blood.value] = 0
+    mapOm[arrPhan==Tissue.Fill.value] = 0
+    mapOm[arrPhan==Tissue.Vessel.value] = 0
+    return mapOm

mrphantom-0.0.0/slime_src/__init__.py

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

mrphantom-0.0.0/slime_src/ext/main.cpp

@@ -0,0 +1,66 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <numpy/arrayobject.h>
+
+#include <vector>
+#include <cstring>
+#include <slime.h>
+
+bool inline checkNarg(int64_t lNarg, int64_t lNargExp)
+{
+    if (lNarg != lNargExp)
+    {
+        printf("wrong num. of arg, narg=%ld, %ld expected\n", lNarg, lNargExp);
+        abort();
+        return false;
+    }
+    return true;
+}
+
+static PyObject* genPhant_py(PyObject* self, PyObject* const* args, Py_ssize_t nargs)
+{
+    checkNarg(nargs,4);
+    int64_t lNAx = PyLong_AsLongLong(args[0]);
+    int64_t lNPix = PyLong_AsLongLong(args[1]);
+    double dResAmp = PyFloat_AsDouble(args[2]);
+    double dCarAmp = PyFloat_AsDouble(args[3]);
+
+    // Generate into std::vector
+    std::vector<uint8_t> vu8Phant;
+    genPhant(lNAx, lNPix, dResAmp, dCarAmp, &vu8Phant);
+
+    // convert vector to numpy array
+    PyObject* ppyoNpa;
+    {
+        npy_intp aDims[] = {lNPix, lNPix, lNPix};
+        ppyoNpa = PyArray_ZEROS(lNAx, aDims, NPY_UINT8, 0);
+    }
+
+    // fill the data in
+    std::memcpy(PyArray_DATA((PyArrayObject*)ppyoNpa),
+                vu8Phant.data(),
+                vu8Phant.size() * sizeof(uint8_t));
+
+    return ppyoNpa;
+}
+
+static PyMethodDef aMeth[] =
+{
+    {"genPhant", (PyCFunction)genPhant_py, METH_FASTCALL, "genPhant(lNAx, lNPix, dResAmp, dCarAmp) -> np.ndarray[uint8]"},
+    {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef sMod =
+{
+    PyModuleDef_HEAD_INIT,
+    "ext",
+    NULL,
+    -1,
+    aMeth
+};
+
+PyMODINIT_FUNC PyInit_ext(void)
+{
+    import_array();  // required for NumPy C-API
+    return PyModule_Create(&sMod);
+}

mrphantom-0.0.0/slime_src/ext/slime.cpp

@@ -0,0 +1,163 @@
+#include <vector>
+#include <cstdint>
+#include <cmath>
+#include <stdexcept>
+
+#include <omp.h>
+
+// Tissue
+enum Tissue : uint8_t
+{
+    Air = 0,
+    Fat = 1,
+    Myo = 2,
+    Blood = 3,
+    Fill = 4, // we fill the remaining with skeletal mussles
+    Vessel = 5,
+};
+
+bool isInsideEllipsoid
+(
+    double x, double y, double z,
+    double cx, double cy, double cz,
+    double rX, double rY, double rZ
+)
+{
+    if (rX <= 0e0 || rY <= 0e0 || rZ <= 0e0) return false;
+
+    const double dx = x - cx;
+    const double dy = y - cy;
+    const double dz = z - cz;
+
+    const double v =
+        (dx*dx) / (rX*rX) +
+        (dy*dy) / (rY*rY) +
+        (dz*dz) / (rZ*rZ);
+
+    return v <= 1e0;
+}
+
+bool genPhant
+(
+    int64_t lNAx, int64_t lNPix,
+    double dResAmp, double dCarAmp,
+    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));
+
+    // 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 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 dMyoOt_rY = dNPix*100e-3 + dNPix*dCarAmp;
+    const double dMyoOt_rX = dNPix*120e-3 + dNPix*dCarAmp;
+    const double dMyoOt_rZ = dMyoOt_rY;
+
+    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;
+
+    // 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;
+
+    /* generate phantom given by `dResAmp` and `dCarAmp` here */
+    #pragma omp parallel for schedule(static)
+    for (int64_t i = 0; i < lNPix_Flat; ++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;
+
+        // decide what tissue current pixel is
+        if (!isInsideEllipsoid(x,y,z, dFat_cx,dFat_cy,dFat_cz, dFatOt_rX,dFatOt_rY,dFatOt_rZ))
+        {
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Air;
+            continue;
+        }
+
+        if (!isInsideEllipsoid(x,y,z, dFat_cx,dFat_cy,dFat_cz, dFatIn_rX,dFatIn_rY,dFatIn_rZ))
+        {
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Fat;
+            continue;
+        }
+        
+        // vessel balls (move with FatIn distortion; positioned away from heart)
+        const double dFatIn0_rX = dNPix*380e-3;
+        const double dFatIn0_rY = dNPix*380e-3;
+        const double dFatIn0_rZ = dNPix*450e-3;
+
+        const double sX = dFatIn_rX / dFatIn0_rX;
+        const double sY = dFatIn_rY / dFatIn0_rY;
+        const double sZ = dFatIn_rZ / dFatIn0_rZ;
+
+        // vessel balls
+        #define V_HIT(cx,cy,cz,div) isInsideEllipsoid(x,y,z, ((cx)*dNPix*sX), ((cy)*dNPix*sY), ((cz)*dNPix*sZ), (dFatIn_rX/(div)), (dFatIn_rY/(div)), (dFatIn_rZ/(div)))
+
+        // 48 “random” vessels (cx,cy,cz in dNPix 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) || \
+            V_HIT(-0.19,  0.07,  0.00, 16) || \
+            V_HIT( 0.11, -0.17,  0.00, 19) || \
+            V_HIT(-0.13, -0.16,  0.00, 21) || \
+            V_HIT( 0.04,  0.20,  0.00, 22) || \
+            /* 5 on YZ plane (x = 0) — adjusted to avoid closeness with XZ plane (y=0) */ \
+            V_HIT( 0.00,  0.14,  0.13, 12) || \
+            V_HIT( 0.00, -0.15,  0.12, 16) || \
+            V_HIT( 0.00,  0.09, -0.17, 19) || \
+            V_HIT( 0.00, -0.12, -0.16, 21) || \
+            V_HIT( 0.00,  0.23,  0.06, 22) || \
+            /* 5 on XZ plane (y = 0) — adjusted corresponding “near” one */ \
+            V_HIT( 0.16,  0.00,  0.12, 12) || \
+            V_HIT(-0.17,  0.00,  0.11, 16) || \
+            V_HIT( 0.13,  0.00, -0.16, 19) || \
+            V_HIT(-0.12,  0.00, -0.17, 21) || \
+            V_HIT( 0.23,  0.00, -0.06, 22) || \
+            /* 8 octants (near heart, slightly pushed outward) */ \
+            V_HIT( 0.14,  0.13,  0.12, 16) || /* + + + */ \
+            V_HIT(-0.15,  0.13,  0.12, 16) || /* - + + */ \
+            V_HIT( 0.14, -0.14,  0.12, 16) || /* + - + */ \
+            V_HIT(-0.15, -0.14,  0.12, 16) || /* - - + */ \
+            V_HIT( 0.14,  0.13, -0.13, 16) || /* + + - */ \
+            V_HIT(-0.15,  0.13, -0.13, 16) || /* - + - */ \
+            V_HIT( 0.14, -0.14, -0.13, 16) || /* + - - */ \
+            V_HIT(-0.15, -0.14, -0.13, 16)    /* - - - */
+
+        if ( VLIST )
+        {
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Vessel;
+            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;
+            continue;
+        }
+
+        if (!isInsideEllipsoid(x,y,z, dMyoIn_cx,dMyoIn_cy,dMyoIn_cz, dMyoIn_rX,dMyoIn_rY,dMyoIn_rZ))
+        {
+            (*voSlime)[(size_t)i] = (uint8_t)Tissue::Myo;
+            continue;
+        }
+
+        (*voSlime)[(size_t)i] = (uint8_t)Tissue::Blood;
+    }
+
+    return true;
+}

mrphantom-0.0.0/slime_src/ext/slime.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <vector>
+#include <cstdint>
+
+extern bool genPhant
+(
+    int64_t lNDim, int64_t lNPix,
+    double dResAmp, double dCarAmp,
+    std::vector<uint8_t>* voSlime
+);