rapidtide 3.0.1__py3-none-any.whl → 3.0.2__py3-none-any.whl

rapidtide/voxelData.py

@@ -16,14 +16,78 @@
 #   limitations under the License.
 #
 #
+import copy
+
 import numpy as np
-from tf_keras.src.layers.preprocessing.benchmarks.index_lookup_forward_benchmark import (
-    get_vocab,
-)
 from tqdm import tqdm
 
 import rapidtide.filter as tide_filt
 import rapidtide.io as tide_io
+import rapidtide.util as tide_util
+
+
+class dataVolume:
+    xsize = None
+    ysize = None
+    numslices = None
+    numspatiallocs = None
+    timepoints = None
+    dtype = None
+    dimensions = None
+    data = None
+    data_shm = None
+    thepid = None
+
+    def __init__(
+        self,
+        shape,
+        shared=False,
+        dtype=np.float64,
+        thepid=0,
+    ):
+        if len(shape) == 3:
+            self.xsize = int(shape[0])
+            self.ysize = int(shape[1])
+            self.numslices = int(shape[2])
+            self.timepoints = 1
+            self.dimensions = 3
+        elif len(shape) == 4:
+            self.xsize = int(shape[0])
+            self.ysize = int(shape[1])
+            self.numslices = int(shape[2])
+            self.timepoints = int(shape[3])
+            self.dimensions = 4
+        else:
+            print(f"illegal shape: {shape}")
+        self.numspatiallocs = self.xsize * self.ysize * self.numslices
+        self.dtype = dtype
+        if not shared:
+            self.data = np.zeros(shape, dtype=dtype)
+        else:
+            self.data, self.data_shm = tide_util.allocshared(
+                shape, self.dtype, name=f"filtereddata_{thepid}"
+            )
+        return self.data
+
+    def byvol(self):
+        return self.data
+
+    def byslice(self):
+        if self.dimensions == 3:
+            return self.data.reshape(self.xsize * self.ysize, -1)
+        else:
+            return self.data.reshape(self.xsize * self.ysize, self.numslices, -1)
+
+    def byvoxel(self):
+        if self.dimensions == 3:
+            return self.data.reshape(self.numspatiallocs)
+        else:
+            return self.data.reshape(self.numspatiallocs, -1)
+
+    def destroy(self):
+        del self.data
+        if self.data_shm is not None:
+            tide_util.cleanup_shm(self.data_shm)
 
 
 class VoxelData:
@@ -36,14 +100,17 @@ class VoxelData:
     ysize = None
     numslices = None
     timepoints = None
+    realtimepoints = None
     xdim = None
     ydim = None
     slicethickness = None
     timestep = None
     thesizes = None
     thedims = None
+    numslicelocs = None
     numspatiallocs = None
     nativespaceshape = None
+    nativefmrishape = None
     validvoxels = None
     cifti_hdr = None
     filetype = None
@@ -71,7 +138,8 @@ class VoxelData:
             self.xsize = self.theshape[0]
             self.ysize = 1
             self.numslices = 1
-            self.timepoints = self.theshape[1]
+            self.numslicelocs = None
+            self.timepoints = int(self.theshape[1])
             self.thesizes = [0, int(self.xsize), 1, 1, int(self.timepoints)]
             self.toffset = 0.0
             self.numspatiallocs = int(self.xsize)
@@ -81,7 +149,8 @@ class VoxelData:
             if tide_io.checkifcifti(self.filename):
                 self.filetype = "cifti"
                 self.nim_affine = None
-                self.timepoints = self.nim_data.shape[1]
+                self.numslicelocs = None
+                self.timepoints = int(self.nim_data.shape[1])
                 self.numspatiallocs = self.nim_data.shape[0]
                 self.nativespaceshape = (1, 1, 1, 1, self.numspatiallocs)
             else:
@@ -90,6 +159,7 @@ class VoxelData:
                 self.xsize, self.ysize, self.numslices, self.timepoints = tide_io.parseniftidims(
                     self.thedims
                 )
+                self.numslicelocs = int(self.xsize) * int(self.ysize)
                 self.numspatiallocs = int(self.xsize) * int(self.ysize) * int(self.numslices)
                 self.cifti_hdr = None
                 self.nativespaceshape = (self.xsize, self.ysize, self.numslices)
@@ -120,6 +190,30 @@ class VoxelData:
         self.setvalidtimes(validstart, validend)
         self.resident = True
 
+    def copyheader(self, numtimepoints=None, tr=None, toffset=None):
+        if self.filetype == "text":
+            return None
+        else:
+            thisheader = copy.deepcopy(self.nim_hdr)
+            if self.filetype == "cifti":
+                timeindex = thisheader["dim"][0] - 1
+                spaceindex = thisheader["dim"][0]
+                thisheader["dim"][timeindex] = numtimepoints
+                thisheader["dim"][spaceindex] = self.numspatiallocs
+            else:
+                if numtimepoints is not None:
+                    thisheader["dim"][4] = numtimepoints
+                    if numtimepoints > 1:
+                        thisheader["dim"][0] = 4
+                    else:
+                        thisheader["dim"][0] = 3
+                        thisheader["pixdim"][4] = 1.0
+                if toffset is not None:
+                    thisheader["toffset"] = toffset
+                if tr is not None:
+                    thisheader["pixdim"][4] = tr
+            return thisheader
+
     def getsizes(self):
         return self.xdim, self.ydim, self.slicethickness, self.timestep
 
@@ -167,32 +261,48 @@ class VoxelData:
             self.validend = self.timepoints - 1
         else:
             self.validend = validend
+        self.realtimepoints = self.validend - self.validstart + 1
+        if self.filetype == "nifti":
+            self.nativefmrishape = (self.xsize, self.ysize, self.numslices, self.realtimepoints)
+        elif self.filetype == "cifti":
+            self.nativefmrishape = (1, 1, 1, self.realtimepoints, self.numspatiallocs)
+        else:
+            self.nativefmrishape = (self.xsize, self.realtimepoints)
 
     def setvalidvoxels(self, validvoxels):
         self.validvoxels = validvoxels
         self.numvalidspatiallocs = np.shape(self.validvoxels)[0]
 
-    def native(self):
+    def byvol(self):
         if not self.resident:
             self.load()
         return self.nim_data
 
-    def nativetrimmed(self):
+    def byvoltrimmed(self):
         if not self.resident:
             self.load()
         if self.filetype == "nifti":
             return self.nim_data[:, :, :, self.validstart : self.validend + 1]
         else:
-            return self.nim_data[:, self.validstart: self.validend + 1]
+            return self.nim_data[:, self.validstart : self.validend + 1]
+
+    def byvoxel(self):
+        return self.byvoltrimmed().reshape(self.numspatiallocs, -1)
 
-    def voxelbytime(self):
-        return self.nativetrimmed().reshape(self.numspatiallocs, -1)
+    def byslice(self):
+        return self.byvoltrimmed().reshape(self.numslicelocs, self.numslices, -1)
 
-    def getvalidvoxels(self):
+    def validdata(self):
         if self.validvoxels is None:
-            return self.voxelbytime()
+            return self.byvoxel()
         else:
-            return self.voxelbytime()[self.validvoxels, :]
+            return self.byvoxel()[self.validvoxels, :]
+
+    # def validdatabyslice(self):
+    #    if self.validvoxels is None:
+    #       return self.byslice()
+    #    else:
+    #        return self.byvoxel()[self.validvoxels, :].reshape(self.numslicelocs, self.numslices, -1)
 
     def smooth(
         self,
@@ -241,7 +351,7 @@ class VoxelData:
                 f"applying gaussian spatial filter to timepoints {self.validstart} "
                 f"to {self.validend} with sigma={gausssigma}"
             )
-            sourcedata = self.native()
+            sourcedata = self.byvol()
             for i in tqdm(
                 range(self.validstart, self.validend + 1),
                 desc="Timepoint",
@@ -271,6 +381,7 @@ class VoxelData:
         print(f"\t{self.timestep=}")
         print(f"\t{self.thesizes=}")
         print(f"\t{self.thedims=}")
+        print(f"\t{self.numslicelocs=}")
         print(f"\t{self.numspatiallocs=}")
         print(f"\t{self.nativespaceshape=}")
         print(f"\t{self.cifti_hdr=}")

rapidtide/workflows/delayestimation.py

@@ -130,7 +130,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
     if optiondict["checkpoint"]:
         outcorrarray[:, :] = 0.0
         outcorrarray[validvoxels, :] = corrout[:, :]
-        if optiondict["textio"]:
+        if theinputdata.filetype == "text":
             tide_io.writenpvecs(
                 outcorrarray.reshape(nativecorrshape),
                 f"{outputname}_corrout_prefit_pass" + str(thepass) + ".txt",
@@ -320,8 +320,8 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
         if optiondict["savedespecklemasks"] and (optiondict["despeckle_passes"] > 0):
             despecklesavemask = np.where(internaldespeckleincludemask[validvoxels] == 0.0, 0, 1)
             if thepass == optiondict["passes"]:
-                if not optiondict["textio"]:
-                    if fileiscifti:
+                if theinputdata.filetype != "text":
+                    if theinputdata.filetype == "cifti":
                         timeindex = theheader["dim"][0] - 1
                         spaceindex = theheader["dim"][0]
                         theheader["dim"][timeindex] = 1
@@ -346,8 +346,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                     nativespaceshape,
                     theheader,
                     bidsbasedict,
-                    textio=optiondict["textio"],
-                    fileiscifti=fileiscifti,
+                    filetype=theinputdata.filetype,
                     rt_floattype=rt_floattype,
                     cifti_hdr=cifti_hdr,
                 )
@@ -384,8 +383,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
             nativespaceshape,
             theheader,
             bidsbasedict,
-            textio=optiondict["textio"],
-            fileiscifti=fileiscifti,
+            filetype=theinputdata.filetype,
             rt_floattype=rt_floattype,
             cifti_hdr=cifti_hdr,
         )
@@ -417,8 +415,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )
@@ -442,8 +439,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )
@@ -478,8 +474,7 @@ def estimateDelay(voxeldata, datatimeaxis, osdatatimeaxis, theMutualInformationa
                 nativespaceshape,
                 theheader,
                 bidsbasedict,
-                textio=optiondict["textio"],
-                fileiscifti=fileiscifti,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=cifti_hdr,
             )

rapidtide/workflows/delayvar.py

@@ -36,6 +36,7 @@ import rapidtide.refinedelay as tide_refinedelay
 import rapidtide.resample as tide_resample
 import rapidtide.stats as tide_stats
 import rapidtide.util as tide_util
+import rapidtide.voxelData as tide_voxelData
 import rapidtide.workflows.parser_funcs as pf
 import rapidtide.workflows.regressfrommaps as tide_regressfrommaps
 
@@ -381,19 +382,19 @@ def delayvar(args):
 
     # read the fmri input files
     print("reading fmrifile")
-    fmri_input, fmri_data, fmri_header, fmri_dims, fmri_sizes = tide_io.readfromnifti(
-        args.fmrifile
-    )
+    theinputdata = tide_voxelData.VoxelData(args.fmrifile)
+    xsize, ysize, numslices, timepoints = theinputdata.getdims()
+    xdim, ydim, slicethickness, fmritr = theinputdata.getsizes()
+    fmri_header = theinputdata.copyheader()
+    fmri_data = theinputdata.byvol()
+    numspatiallocs = theinputdata.numspatiallocs
 
     # create the canary file
     Path(f"{outputname}_DELAYVARISRUNNING.txt").touch()
 
     if args.debug:
         print(f"{fmri_data.shape=}")
-    xdim, ydim, slicedim, fmritr = tide_io.parseniftisizes(fmri_sizes)
-    xsize, ysize, numslices, timepoints = tide_io.parseniftidims(fmri_dims)
-    numspatiallocs = int(xsize) * int(ysize) * int(numslices)
-    fmri_data_spacebytime = fmri_data.reshape((numspatiallocs, timepoints))
+    fmri_data_spacebytime = theinputdata.byvoxel()
     if args.debug:
         print(f"{fmri_data_spacebytime.shape=}")
 
@@ -530,7 +531,7 @@ def delayvar(args):
 
     if args.windelayoffsetgausssigma < 0.0:
         # set gausssigma automatically
-        args.windelayoffsetgausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
+        args.windelayoffsetgausssigma = np.mean([xdim, ydim, slicethickness]) / 2.0
 
     wintrs = int(np.round(args.windowsize / fmritr, 0))
     wintrs += wintrs % 2
@@ -590,8 +591,7 @@ def delayvar(args):
                 (xsize, ysize, numslices, validtimepoints),
                 theheader,
                 bidsbasedict,
-                textio=therunoptions["textio"],
-                fileiscifti=False,
+                filetype=theinputdata.filetype,
                 rt_floattype=rt_floattype,
                 cifti_hdr=None,
             )
@@ -737,11 +737,9 @@ def delayvar(args):
             windowedregressderivratios[:, thewin],
             (xsize, ysize, numslices),
             validvoxels,
-            (xdim, ydim, slicedim),
+            (xdim, ydim, slicethickness),
             gausssigma=args.windelayoffsetgausssigma,
             patchthresh=args.delaypatchthresh,
-            fileiscifti=False,
-            textio=False,
             rt_floattype=rt_floattype,
             verbose=args.verbose,
             debug=args.debug,