MRArbGrad 3.1.0__tar.gz → 4.1.0__tar.gz

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0/MRArbGrad.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 3.1.0
+Version: 4.1.0
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT
@@ -41,7 +41,7 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
+## Reference
 If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
 
 [1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 

{mrarbgrad-3.1.0/MRArbGrad.egg-info → mrarbgrad-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 3.1.0
+Version: 4.1.0
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT
@@ -41,7 +41,7 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
+## Reference
 If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
 
 [1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/README.md

@@ -27,7 +27,7 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
+## Reference
 If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
 
 [1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/Function.py

@@ -142,7 +142,6 @@ def getG_VDSpiral_RT\
     
     kRhoPhi0: float64 = 0.5 / (8 * pi),
     kRhoPhi1: float64 = 0.5 / (2 * pi),
-    nAcq: int64 = 128,
 ) -> tuple[list[NDArray], list[NDArray]]:
     '''
     :return: list of trajectory start, list of gradient waveforms
@@ -158,9 +157,7 @@ def getG_VDSpiral_RT\
         float64(dt),
         
         float64(kRhoPhi0),
-        float64(kRhoPhi1),
-        
-        int64(nAcq)
+        float64(kRhoPhi1)
     )
 
 def getG_Rosette\
@@ -294,8 +291,7 @@ def getG_Yarnball_RT\
     gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
     dt: float64 = 10e-6,
     
-    kRhoPhi: float64 = 0.5 / (2 * pi),
-    nAcq: int64 = 16384,
+    kRhoPhi: float64 = 0.5 / (2 * pi)
 ) -> tuple[list[NDArray], list[NDArray]]:
     '''
     :return: list of trajectory start, list of gradient waveforms
@@ -310,8 +306,7 @@ def getG_Yarnball_RT\
         float64(gLim),
         float64(dt),
         
-        float64(kRhoPhi),
-        int64(nAcq),
+        float64(kRhoPhi)
     )
 
 def getG_Seiffert\
@@ -381,3 +376,29 @@ def setMagSFS(x): ext.setMagSFS(x)
 def setMagGradRep(x): ext.setMagGradRep(x)
 def setMagTrajRep(x): ext.setMagTrajRep(x)
 def setDbgPrint(x): ext.setDbgPrint(x)
+
+def loadF64(hdr:str, bin:str) -> list[NDArray]:
+    """
+    load saved vector file (float64)
+
+    Args:
+        hdr (str): header (hdr) file path
+        bin (str): bin file path
+
+    Returns:
+        list[NDArray]: list of loaded array
+    """
+    return ext.loadF64(str(hdr), str(bin))
+
+def loadF32(hdr:str, bin:str) -> list[NDArray]:
+    """
+    load saved vector file (float32)
+
+    Args:
+        hdr (str): header (hdr) file path
+        bin (str): bin file path
+
+    Returns:
+        list[NDArray]: list of loaded array
+    """
+    return ext.loadF32(str(hdr), str(bin))

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/__init__.py

@@ -1,6 +1,6 @@
 from .Function import calGrad4ExFunc, calGrad4ExSamp
 from .Function import getG_Cones, getG_Rosette, getG_Rosette_Trad, getG_Seiffert, getG_Shell3d, getG_Spiral, getG_VDSpiral, getG_VDSpiral_RT, getG_Yarnball, getG_Yarnball_RT
-from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint
+from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint, loadF64, loadF32
 from .Utility import _calDiaphony, rotate, _calJacElip, _calCompElipInt, _calSphFibPt, cvtGrad2Traj, getGoldang, getGoldrat, rand3d, gradClip
 
 from . import trajfunc

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/main.cpp

@@ -137,7 +137,7 @@ bool inline checkNarg(i64 nArg, i64 nArgExp)
 {
     if (nArg != nArgExp)
     {
-        printf("wrong num. of arg, narg=%ld, %ld expected\n", nArg, nArgExp);
+        printf("wrong num. of arg, narg=%ld, %ld expected\n", (long)nArg, (long)nArgExp);
         abort();
         return false;
     }
@@ -389,7 +389,7 @@ bool getG(MrTraj* pmt, vv3* pvv3M0PE, vvv3* pvvv3GRO)
     pvvv3GRO->resize(nAcq);
 
     bool& enShuf = gMain_enShuffle;
-	vi64 vi64ShufSeq; MrTraj::genRandIdx(&vi64ShufSeq, nAcq);
+	vi64 vi64ShufSeq; MrTraj::genPermTab(&vi64ShufSeq, nAcq);
     for (i64 i = 0; i < nAcq; ++i)
     {
         i64 _i = enShuf?vi64ShufSeq[i]:i;
@@ -451,7 +451,7 @@ PyObject* getG_VDSpiral(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_VDSpiral_RT(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 8);
+    checkNarg(narg, 7);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -459,8 +459,7 @@ PyObject* getG_VDSpiral_RT(PyObject* self, PyObject* const* args, Py_ssize_t nar
 
     f64 kRhoPhi0 = (f64)PyFloat_AsDouble(args[5]);
     f64 kRhoPhi1 = (f64)PyFloat_AsDouble(args[6]);
-    i64 nAcq = (i64)PyLong_AsLong(args[7]);
-    VDSpiral_RT traj(objGeoPara, objGradPara, kRhoPhi0, kRhoPhi1, nAcq);
+    VDSpiral_RT traj(objGeoPara, objGradPara, kRhoPhi0, kRhoPhi1);
 
     vv3 vv3K0;
     vvv3 vvv3G;
@@ -555,15 +554,14 @@ PyObject* getG_Yarnball(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_Yarnball_RT(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 7);
+    checkNarg(narg, 6);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
     getGeoGradPara(args, &objGeoPara, &objGradPara);
 
     f64 kRhoPhi = (f64)PyFloat_AsDouble(args[5]);
-    i64 nAcq = (i64)PyLong_AsLong(args[6]);
-    Yarnball_RT traj(objGeoPara, objGradPara, kRhoPhi, nAcq);
+    Yarnball_RT traj(objGeoPara, objGradPara, kRhoPhi);
 
     vv3 vv3K0;
     vvv3 vvv3G;
@@ -709,11 +707,46 @@ PyObject* setDbgPrint(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     return Py_None;
 }
 
-vv3 vv3Test;
-PyObject* getTestVal(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+PyObject* loadF64(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 0);
-    return Py_BuildValue("O", cvtVv3toNpa(vv3Test));
+    checkNarg(narg, 2);
+    const char* strHdr = PyUnicode_AsUTF8(args[0]);
+    const char* strBin = PyUnicode_AsUTF8(args[1]);
+    typedef std::list<vv3> lvv3;
+    FILE* fHdr = fopen(strHdr, "r");
+    FILE* fBin = fopen(strHdr, "rb");
+
+    lvv3 lvv3Data;
+    bool ret; vv3 vv3Data;
+    while (1)
+    {
+        ret = v3::loadF64(fHdr, fBin, &vv3Data);
+        if (vv3Data.empty() || !ret) break;
+        lvv3Data.push_back(vv3Data);
+    }
+    vvv3 vvv3Data(lvv3Data.begin(), lvv3Data.end());
+    Py_BuildValue("%O", cvtVvv3toList(vvv3Data));
+}
+
+PyObject* loadF32(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    checkNarg(narg, 2);
+    const char* strHdr = PyUnicode_AsUTF8(args[0]);
+    const char* strBin = PyUnicode_AsUTF8(args[1]);
+    typedef std::list<vv3> lvv3;
+    FILE* fHdr = fopen(strHdr, "r");
+    FILE* fBin = fopen(strHdr, "rb");
+
+    lvv3 lvv3Data;
+    bool ret; vv3 vv3Data;
+    while (1)
+    {
+        ret = v3::loadF32(fHdr, fBin, &vv3Data);
+        if (vv3Data.empty() || !ret) break;
+        lvv3Data.push_back(vv3Data);
+    }
+    vvv3 vvv3Data(lvv3Data.begin(), lvv3Data.end());
+    Py_BuildValue("%O", cvtVvv3toList(vvv3Data));
 }
 
 static PyMethodDef aMeth[] = 
@@ -736,12 +769,13 @@ static PyMethodDef aMeth[] =
     {"setShuf", (PyCFunction)setShuf, METH_FASTCALL, ""},
     {"setMaxG0", (PyCFunction)setMaxG0, METH_FASTCALL, ""},
     {"setMaxG1", (PyCFunction)setMaxG1, METH_FASTCALL, ""},
-    {"getTestVal", (PyCFunction)getTestVal, METH_FASTCALL, ""},
     {"setMagOverSamp", (PyCFunction)setMagOverSamp, METH_FASTCALL, ""},
     {"setMagSFS", (PyCFunction)setMagSFS, METH_FASTCALL, ""},
     {"setMagGradRep", (PyCFunction)setMagGradRep, METH_FASTCALL, ""},
     {"setMagTrajRep", (PyCFunction)setMagTrajRep, METH_FASTCALL, ""},
     {"setDbgPrint", (PyCFunction)setDbgPrint, METH_FASTCALL, ""},
+    {"loadF64", (PyCFunction)loadF64, METH_FASTCALL, ""},
+    {"loadF32", (PyCFunction)loadF32, METH_FASTCALL, ""},
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };
 

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/traj/MrTraj.h

@@ -95,7 +95,7 @@ public:
     }
 
     // a deterministic shuffle sequence generator
-    static bool genRandIdx(vi64* pvi64Idx, i64 len)
+    static bool genPermTab(vi64* pvi64Idx, i64 len)
     {
         // resize target container rationally
         pvi64Idx->clear();

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/traj/Shell3d.h

@@ -80,18 +80,18 @@ public:
     {
         bool ret = true;
         const f64& rotang = m_rotang;
-        i64 iSet = iAcq%m_nRot;
-        i64 iRot = iAcq/m_nRot;
+        i64 iPhi = iAcq%m_nRot;
+        i64 iTht = iAcq/m_nRot%m_nRot;
 
         if (pv3M0PE)
         {
-            *pv3M0PE = m_vv3BaseM0PE[iSet];
-            ret &= v3::rotate(pv3M0PE, 2, rotang * iRot, *pv3M0PE);
+            *pv3M0PE = m_vv3BaseM0PE[iTht];
+            ret &= v3::rotate(pv3M0PE, 2, rotang*iPhi, *pv3M0PE);
         }
         if (pvv3GRO)
         {
-            *pvv3GRO = m_vvv3BaseGRO[iSet];
-            ret &= v3::rotate(pvv3GRO, 2, rotang * iRot, *pvv3GRO);
+            *pvv3GRO = m_vvv3BaseGRO[iTht];
+            ret &= v3::rotate(pvv3GRO, 2, rotang*iPhi, *pvv3GRO);
         }
 
         return ret;

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/traj/VDSpiral.h

@@ -70,21 +70,21 @@ class VDSpiral_RT: public MrTraj
 {
     // TODO: Goldang sampling is incomplete, shuffled sampling is incomplete.
 public:
-    VDSpiral_RT(const GeoPara& objGeoPara, const GradPara& objGradPara, f64 kRhoPhi0, f64 kRhoPhi1, i64 nAcq):
+    VDSpiral_RT(const GeoPara& objGeoPara, const GradPara& objGradPara, f64 kRhoPhi0, f64 kRhoPhi1):
     /*
      * nAcq: Num of Acq, used to preallocate an array to store PE M0
      */
-        MrTraj(objGeoPara,objGradPara,nAcq,0)
+        MrTraj(objGeoPara,objGradPara,0,0)
     {
         m_kRhoPhi0 = kRhoPhi0;
         m_kRhoPhi1 = kRhoPhi1;
-        m_nRot = calNRot(kRhoPhi1, objGeoPara.nPix);
-        m_dRotAng = 2e0*M_PI/m_nRot;
-        genRandIdx(&m_vi64Idx, m_nRot);
+        m_nAcq = calNRot(kRhoPhi1, objGeoPara.nPix);
+        m_dRotAng = 2e0*M_PI/m_nAcq;
+        genPermTab(&m_vi64PermTab, m_nAcq);
 
         VDSpiral_TrajFunc tf(m_kRhoPhi0, m_kRhoPhi1, 0);
         vv3 vv3GRO; calGrad(NULL, &vv3GRO, NULL, tf, m_objGradPara, 4);
-        m_nSampMax = vv3GRO.size();
+        m_nSampMax = vv3GRO.size() + 0;
     }
 
     virtual ~VDSpiral_RT()
@@ -93,15 +93,17 @@ public:
     virtual bool getGrad(v3* pv3M0PE, vv3* pvv3GRO, i64 iAcq)
     {
         bool ret = true;
-        VDSpiral_TrajFunc tf(m_kRhoPhi0, m_kRhoPhi1, m_vi64Idx[iAcq]*m_dRotAng);
-        ASSERT(iAcq < m_nAcq);
-        ret &= calGrad(pv3M0PE, pvv3GRO, NULL, tf, m_objGradPara, 4);
+        ASSERT(iAcq >= 0);
+        i64 iPhi = m_vi64PermTab[iAcq%m_nAcq];
+        f64 phi = iPhi*m_dRotAng;
+        VDSpiral_TrajFunc tf(m_kRhoPhi0, m_kRhoPhi1, phi);
+        ret &= calGrad(pv3M0PE, pvv3GRO, NULL, tf, m_objGradPara, 2);
         return ret;
     }
 
 protected:
     f64 m_kRhoPhi0;
     f64 m_kRhoPhi1;
-    i64 m_nRot; f64 m_dRotAng;
-    vi64 m_vi64Idx;
+    f64 m_dRotAng;
+    vi64 m_vi64PermTab;
 };

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/traj/Yarnball.h

@@ -80,14 +80,20 @@ public:
     {
         bool ret = true;
         const f64& rotang = m_rotang;
-        i64 iSet = iAcq%m_nRot;
-        i64 iRot = iAcq/m_nRot;
+        i64 iPhi = iAcq%m_nRot;
+        i64 iTht = iAcq/m_nRot%m_nRot;
+
+        if (pv3M0PE)
+        {
+            *pv3M0PE = m_vv3BaseM0PE[iTht];
+            ret &= v3::rotate(pv3M0PE, 2, rotang*iPhi, *pv3M0PE);
+        }
+        if (pvv3GRO)
+        {
+            *pvv3GRO = m_vvv3BaseGRO[iTht];
+            ret &= v3::rotate(pvv3GRO, 2, rotang*iPhi, *pvv3GRO);
+        }
 
-        *pv3M0PE = m_vv3BaseM0PE[iSet];
-        *pvv3GRO = m_vvv3BaseGRO[iSet];
-        ret &= v3::rotate(pv3M0PE, 2, rotang*iRot, *pv3M0PE);
-        ret &= v3::rotate(pvv3GRO, 2, rotang*iRot, *pvv3GRO);
-        
         return ret;
     }
 
@@ -100,21 +106,21 @@ protected:
     vvv3 m_vvv3BaseGRO;
 };
 
-/* incomplete - we plan to test 2D real-time first before 3D */
 class Yarnball_RT: public MrTraj
 {
 public:
-    Yarnball_RT(const GeoPara& objGeoPara, const GradPara& objGradPara, f64 kRhoPhi, i64 nAcq):
-        MrTraj(objGeoPara, objGradPara, nAcq, 0)
+    Yarnball_RT(const GeoPara& objGeoPara, const GradPara& objGradPara, f64 kRhoPhi):
+        MrTraj(objGeoPara,objGradPara,0,0)
     {
         m_kRhoPhi = kRhoPhi;
         m_nRot = calNRot(kRhoPhi, objGeoPara.nPix);
         m_dRotAng = 2e0*M_PI/m_nRot;
-        genRandIdx(&m_vi64Idx, m_nRot);
+        m_nAcq = m_nRot*m_nRot;
+        genPermTab(&m_vi64PermTab, m_nAcq);
         
         Yarnball_TrajFunc tf(m_kRhoPhi, M_PI/2e0, 0);
         vv3 vv3GRO; calGrad(NULL, &vv3GRO, NULL, tf, m_objGradPara, 4);
-        m_nSampMax = vv3GRO.size();
+        m_nSampMax = vv3GRO.size() + 1; // 1 for redundance
     }
 
     virtual ~Yarnball_RT()
@@ -123,18 +129,18 @@ public:
     virtual bool getGrad(v3* pv3M0PE, vv3* pvv3GRO, i64 iAcq)
     {
         bool ret = true;
-        i64 iTht = iAcq%m_nRot;
-        i64 iPhi = iAcq/m_nRot;
-        f64 tht = m_dRotAng*m_vi64Idx[iTht];
-        f64 phi = m_dRotAng*m_vi64Idx[iPhi];
+        ASSERT(iAcq >= 0);
+        i64 iPhi = m_vi64PermTab[iAcq%m_nAcq]%m_nRot;
+        i64 iTht = m_vi64PermTab[iAcq%m_nAcq]/m_nRot;
+        f64 phi = m_dRotAng*iPhi;
+        f64 tht = m_dRotAng*iTht;
         Yarnball_TrajFunc tf(m_kRhoPhi, tht, phi);
-        ASSERT(iAcq<m_nAcq);
-        ret &= calGrad(pv3M0PE, pvv3GRO, NULL, tf, m_objGradPara, 4);
+        ret &= calGrad(pv3M0PE, pvv3GRO, NULL, tf, m_objGradPara, 2);
         return ret;
     }
 
 protected:
     f64 m_kRhoPhi;
     i64 m_nRot; f64 m_dRotAng;
-    vi64 m_vi64Idx;
+    vi64 m_vi64PermTab;
 };

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/utility/global.h

@@ -24,6 +24,10 @@ typedef std::vector<i64> vi64;
 typedef std::vector<f64> vf64;
 typedef std::list<i64> li64;
 typedef std::list<f64> lf64;
+typedef std::vector<i32> vi32;
+typedef std::vector<f32> vf32;
+typedef std::list<i32> li32;
+typedef std::list<f32> lf32;
 
 typedef std::string str;
 
@@ -49,7 +53,7 @@ inline T gcd(T x, T y)
 #define GOLDRAT (1.6180339887498949e0) // ((1e0+std::sqrt(5e0))/2e0)
 #define GOLDANG (2.3999632297286531e0) // ((3e0-std::sqrt(5e0))*M_PI)
 
-#define PRINT(X) {printf("%s: %ld\n", #X, (i64)(X));}
+#define PRINT(X) {printf("%s: %ld\n", #X, (long)(X));}
 #define PRINT_F(X) {printf("%s: %.3lf\n", #X, (f64)(X));}
 #define PRINT_E(X) {printf("%s: %.3e\n", #X, (f64)(X));}
 #define ASSERT(X) {if(!(X)) throw std::runtime_error(#X);}
@@ -62,4 +66,3 @@ inline T gcd(T x, T y)
     if (glob_enDbgPrint) printf("Elapsed time: %.3lf ms\n", 1e3*cTick/CLOCKS_PER_SEC);
 
 extern bool glob_enDbgPrint;
-    

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/mrarbgrad_src/ext/utility/v3.cpp

@@ -1,5 +1,6 @@
 #include "v3.h"
 #include <array>
+#include <cinttypes>
 
 v3::v3() :x(0e0), y(0e0), z(0e0) {}
 v3::v3(f64 _) :x(_), y(_), z(_) {}
@@ -362,4 +363,80 @@ v3 v3::axisroll(const v3& v3In, i64 nShift)
         break;
     }
     return v3Ot;
-}
+}
+
+bool v3::saveF64(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data)
+{
+    bool ret = true;
+    i64 lenData = vv3Data.size();
+    fprintf(pfHdr, "float64[%ld][3];\n", (long)lenData);
+
+    f64* bufFile = new f64[lenData*3];
+    for(i64 i=0; i<(i64)lenData; ++i)
+    {
+        for(i64 j=0; j<3; ++j)
+        { bufFile[3*i+j] = (f64)vv3Data[i][j]; }
+    }
+    ret &= (i64)fwrite(bufFile, sizeof(f64), lenData*3, pfBin)==lenData*3;
+    delete[] bufFile;
+    return ret;
+}
+
+bool v3::loadF64(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data)
+{
+    bool ret = true;
+    i64 lenData = 0;
+    pvv3Data->clear();
+    int nRead = fscanf(pfHdr, "float64[%" SCNi64 "][3];\n", &lenData);
+    if (nRead==EOF) return true; // EOF
+    else if (nRead!=1) return false;
+    pvv3Data->resize(lenData);
+
+    f64* bufFile = new f64[lenData*3];
+    ret &= (i64)fread(bufFile, sizeof(f64), lenData*3, pfBin)==lenData*3;
+    for(i64 i=0; i<(i64)pvv3Data->size(); ++i)
+    {
+        for(i64 j=0; j<3; ++j)
+        { (*pvv3Data)[i][j] = (f64)bufFile[3*i+j]; }
+    }
+    delete[] bufFile;
+    return ret;
+}
+
+bool v3::saveF32(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data)
+{
+    bool ret = true;
+    i64 lenData = vv3Data.size();
+    fprintf(pfHdr, "float32[%ld][3];\n", (long)lenData);
+
+    f32* bufFile = new f32[lenData*3];
+    for(i64 i=0; i<(i64)lenData; ++i)
+    {
+        for(i64 j=0; j<3; ++j)
+        { bufFile[3*i+j] = (f32)vv3Data[i][j]; }
+    }
+    ret &= (i64)fwrite(bufFile, sizeof(f32), lenData*3, pfBin)==lenData*3;
+    delete[] bufFile;
+    return ret;
+}
+
+bool v3::loadF32(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data)
+{
+    bool ret = true;
+    i64 lenData = 0;
+    pvv3Data->clear();
+    int nRead = fscanf(pfHdr, "float32[%" SCNi64 "][3];\n", &lenData);
+    if (nRead==EOF) return true; // EOF
+    else if (nRead!=1) return false;
+    pvv3Data->resize(lenData);
+
+    f32* bufFile = new f32[lenData*3];
+    ret &= (i64)fread(bufFile, sizeof(f32), lenData*3, pfBin)==lenData*3;
+    for(i64 i=0; i<(i64)pvv3Data->size(); ++i)
+    {
+        for(i64 j=0; j<3; ++j)
+        { (*pvv3Data)[i][j] = (f64)bufFile[3*i+j]; }
+    }
+    delete[] bufFile;
+    return ret;
+}

mrarbgrad-4.1.0/mrarbgrad_src/ext/utility/v3.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <cmath>
+#include <list>
+#include <array>
+#include "global.h"
+
+class v3;
+
+typedef std::vector<v3> vv3;
+typedef std::vector<vv3> vvv3;
+typedef std::list<v3> lv3;
+
+class v3
+{
+public:
+    f64 x, y, z;
+
+    v3();
+    v3(f64 _);
+    v3(f64 x, f64 y, f64 z);
+    ~v3();
+    v3 operator+(const v3 &rhs) const;
+    v3& operator+=(const v3 &rhs);
+    v3 operator+(const f64 &rhs) const;
+    v3& operator+=(const f64 &rhs);
+    v3 operator-(const v3 &rhs) const;
+    v3& operator-=(const v3 &rhs);
+    v3 operator-(const f64 &rhs) const;
+    v3& operator-=(const f64 &rhs);
+    v3 operator*(const v3 &rhs) const;
+    v3& operator*=(const v3 &rhs);
+    v3 operator*(const f64 &rhs) const;
+    v3& operator*=(const f64 &rhs);
+    v3 operator/(const v3 &rhs) const;
+    v3& operator/=(const v3 &rhs);
+    v3 operator/(const f64 &rhs) const;
+    v3& operator/=(const f64 &rhs);
+    bool operator==(const v3 &rhs) const;
+    bool operator!=(const v3 &rhs) const;
+    f64& operator[](i64 idx);
+    f64 operator[](i64 idx) const;
+    static f64 norm(const v3& v3In);
+    static v3 cross(const v3& v3In0, const v3& v3In1);
+    static f64 inner(const v3& v3In0, const v3& v3In1);
+    static v3 pow(const v3& v3In, f64 exp);
+    static bool rotate
+    (
+        v3* pv3Dst,
+        int iAx, f64 ang,
+        const v3& v3Src
+    );
+    static bool rotate
+    (
+        vv3* pvv3Dst,
+        int iAx, f64 ang,
+        const vv3& vv3Src
+    );
+    static bool rotate
+    (
+        lv3* plv3Dst,
+        int iAx, f64 ang,
+        const lv3& lv3Src
+    );
+    static v3 axisroll(const v3& v3In, i64 lShift);
+    static bool saveF64(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data);
+    static bool loadF64(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data);
+    static bool saveF32(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data);
+    static bool loadF32(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data);
+private:
+    static bool genRotMat(std::array<v3,3>* pav3RotMat, int iAx, f64 ang);
+};

{mrarbgrad-3.1.0 → mrarbgrad-4.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MRArbGrad"
-version = "3.1.0"
+version = "4.1.0"
 dependencies = ["numpy"]
 
 description = "Gradient waveform design tool for arbitrary k-space trajectories."

mrarbgrad-3.1.0/mrarbgrad_src/ext/utility/v3.h

@@ -1,156 +0,0 @@
-#pragma once
-
-#include <cmath>
-#include <list>
-#include <array>
-#include "global.h"
-
-class v3;
-
-typedef std::vector<v3> vv3;
-typedef std::vector<vv3> vvv3;
-typedef std::list<v3> lv3;
-
-class v3
-{
-public:
-    f64 x, y, z;
-
-    v3();
-    v3(f64 _);
-    v3(f64 x, f64 y, f64 z);
-    ~v3();
-    v3 operator+(const v3 &rhs) const;
-    v3& operator+=(const v3 &rhs);
-    v3 operator+(const f64 &rhs) const;
-    v3& operator+=(const f64 &rhs);
-    v3 operator-(const v3 &rhs) const;
-    v3& operator-=(const v3 &rhs);
-    v3 operator-(const f64 &rhs) const;
-    v3& operator-=(const f64 &rhs);
-    v3 operator*(const v3 &rhs) const;
-    v3& operator*=(const v3 &rhs);
-    v3 operator*(const f64 &rhs) const;
-    v3& operator*=(const f64 &rhs);
-    v3 operator/(const v3 &rhs) const;
-    v3& operator/=(const v3 &rhs);
-    v3 operator/(const f64 &rhs) const;
-    v3& operator/=(const f64 &rhs);
-    bool operator==(const v3 &rhs) const;
-    bool operator!=(const v3 &rhs) const;
-    f64& operator[](i64 idx);
-    f64 operator[](i64 idx) const;
-    static f64 norm(const v3& v3In);
-    static v3 cross(const v3& v3In0, const v3& v3In1);
-    static f64 inner(const v3& v3In0, const v3& v3In1);
-    static v3 pow(const v3& v3In, f64 exp);
-    static bool rotate
-    (
-        v3* pv3Dst,
-        int iAx, f64 ang,
-        const v3& v3Src
-    );
-    static bool rotate
-    (
-        vv3* pvv3Dst,
-        int iAx, f64 ang,
-        const vv3& vv3Src
-    );
-    static bool rotate
-    (
-        lv3* plv3Dst,
-        int iAx, f64 ang,
-        const lv3& lv3Src
-    );
-    static v3 axisroll(const v3& v3In, i64 lShift);
-    template<typename cv3>
-    static bool saveF64(FILE* pfBHdr, FILE* pfBin, const cv3& cv3Data);
-    template<typename cv3>
-    static bool loadF64(FILE* pfBHdr, FILE* pfBin, cv3* pcv3Data);
-    template<typename cv3>
-    static bool saveF32(FILE* pfBHdr, FILE* pfBin, const cv3& cv3Data);
-    template<typename cv3>
-    static bool loadF32(FILE* pfBHdr, FILE* pfBin, cv3* pcv3Data);
-private:
-    static bool genRotMat(std::array<v3,3>* pav3RotMat, int iAx, f64 ang);
-};
-
-template<typename cv3>
-bool v3::saveF64(FILE* pfBHdr, FILE* pfBin, const cv3& cv3Data)
-{
-    bool ret = true;
-    fprintf(pfBHdr, "float64[%ld][3];\n", (i64)cv3Data.size());
-    typename cv3::const_iterator icv3Data = cv3Data.begin();
-    while (icv3Data!=cv3Data.end())
-    {
-        ret &= (fwrite(&icv3Data->x, sizeof(f64), 1, pfBin) == 1);
-        ret &= (fwrite(&icv3Data->y, sizeof(f64), 1, pfBin) == 1);
-        ret &= (fwrite(&icv3Data->z, sizeof(f64), 1, pfBin) == 1);
-        ++icv3Data;
-    }
-    return ret;
-}
-
-template<typename cv3>
-bool v3::loadF64(FILE* pfBHdr, FILE* pfBin, cv3* pcv3Data)
-{
-    bool ret = true;
-    i64 lenData = 0;
-    int nByte = fscanf(pfBHdr, "float64[%ld][3];\n", &lenData);
-    if (nByte!=1) ret = false;
-    pcv3Data->resize(lenData);
-    typename cv3::iterator icv3Data = pcv3Data->begin();
-    while (icv3Data!=pcv3Data->end())
-    {
-        ret &= (fread(&icv3Data->x, sizeof(f64), 1, pfBin) == 1);
-        ret &= (fread(&icv3Data->y, sizeof(f64), 1, pfBin) == 1);
-        ret &= (fread(&icv3Data->z, sizeof(f64), 1, pfBin) == 1);
-        ++icv3Data;
-    }
-    return ret;
-}
-
-template<typename cv3>
-bool v3::saveF32(FILE* pfBHdr, FILE* pfBin, const cv3& cv3Data)
-{
-    bool ret = true;
-    fprintf(pfBHdr, "float32[%ld][3];\n", (i64)cv3Data.size());
-    typename cv3::const_iterator icv3Data = cv3Data.begin();
-    float f32X, f32Y, f32Z;
-    while (icv3Data!=cv3Data.end())
-    {
-        f32X = (float)icv3Data->x;
-        f32Y = (float)icv3Data->y;
-        f32Z = (float)icv3Data->z;
-        ret &= (fwrite(&f32X, sizeof(float), 1, pfBin) == 1);
-        ret &= (fwrite(&f32Y, sizeof(float), 1, pfBin) == 1);
-        ret &= (fwrite(&f32Z, sizeof(float), 1, pfBin) == 1);
-        ++icv3Data;
-    }
-    return ret;
-}
-
-template<typename cv3>
-bool v3::loadF32(FILE* pfBHdr, FILE* pfBin, cv3* pcv3Data)
-{
-    bool ret = true;
-    i64 lenData = 0;
-    int nByte = fscanf(pfBHdr, "float32[%ld][3];\n", &lenData);
-    if (nByte!=1) ret = false;
-    pcv3Data->resize(lenData);
-    typename cv3::iterator icv3Data = pcv3Data->begin();
-    float f32X, f32Y, f32Z;
-    while (icv3Data!=pcv3Data->end())
-    {
-        ret &= (fread(&f32X, sizeof(float), 1, pfBin) == 1);
-        ret &= (fread(&f32Y, sizeof(float), 1, pfBin) == 1);
-        ret &= (fread(&f32Z, sizeof(float), 1, pfBin) == 1);
-
-        icv3Data->x = (f64)f32X;
-        icv3Data->y = (f64)f32Y;
-        icv3Data->z = (f64)f32Z;
-
-        ++icv3Data;
-    }
-    return ret;
-}