rapidtide 3.0a9__py3-none-any.whl → 3.0a10__py3-none-any.whl

rapidtide/workflows/tidepool.py

@@ -30,7 +30,6 @@ import pandas as pd
 import pyqtgraph as pg
 from nibabel.affines import apply_affine
 from pyqtgraph.Qt import QtCore, QtGui, QtWidgets
-from statsmodels.robust.scale import mad
 
 import rapidtide.util as tide_util
 from rapidtide.Colortables import *
@@ -130,7 +129,86 @@ def _get_parser():
     return parser
 
 
-def selectFile():
+def addDataset(
+    thisdatafileroot,
+    anatname=None,
+    geommaskname=None,
+    userise=False,
+    usecorrout=True,
+    useatlas=False,
+    forcetr=False,
+    forceoffset=False,
+    offsettime=0.0,
+    ignoredimmatch=False,
+):
+    global currentdataset, thesubjects, whichsubject, datafileroots
+    global verbosity
+
+    print("Loading", thisdatafileroot)
+    thissubject = RapidtideDataset(
+        "main",
+        thisdatafileroot,
+        anatname=anatname,
+        geommaskname=geommaskname,
+        userise=userise,
+        usecorrout=usecorrout,
+        useatlas=useatlas,
+        forcetr=forcetr,
+        forceoffset=forceoffset,
+        offsettime=offsettime,
+        verbose=verbosity,
+    )
+    if len(thesubjects) > 0:
+        # check to see that the dimensions match
+        dimmatch, sizematch, spacematch, affinematch = check_rt_spatialmatch(
+            thissubject, thesubjects[0]
+        )
+        if dimmatch or ignoredimmatch:
+            thesubjects.append(thissubject)
+        else:
+            print(f"dataset {thisdatafileroot} does not match loaded data - skipping")
+    else:
+        thesubjects.append(thissubject)
+
+    # list the datasets
+    for idx, subject in enumerate(thesubjects):
+        print(f"subject {idx}: {subject.fileroot}")
+
+
+def updateFileMenu():
+    global thesubjects, whichsubject
+    global fileMenu, sel_open
+    global sel_files
+
+    if pyqtversion == 5:
+        qactionfunc = QtWidgets.QAction
+    else:
+        qactionfunc = QtGui.QAction
+
+    # scrub file menu
+    if sel_files is not None:
+        for sel_file in sel_files:
+            fileMenu.removeAction(sel_file)
+            del sel_file
+
+    # now build it back
+    if len(thesubjects) > 0:
+        sel_files = []
+        for idx, subject in enumerate(thesubjects):
+            if idx == whichsubject:
+                indicator = "\u2714 "
+            else:
+                indicator = "  "
+            sel_files.append(qactionfunc(indicator + subject.fileroot, win))
+            sel_files[-1].triggered.connect(partial(selectDataset, idx))
+            fileMenu.addAction(sel_files[-1])
+
+
+def datasetPicker():
+    global currentdataset, thesubjects, whichsubject, datafileroots
+    global ui, win, defaultdict, overlagGraphicsViews
+    global verbosity
+
     mydialog = QtWidgets.QFileDialog()
     if pyqtversion == 5:
         options = mydialog.Options()
@@ -146,7 +224,36 @@ def selectFile():
         datafileroot = str(lagfilename[:bidsstartloc])
     else:
         datafileroot = str(lagfilename[: lagfilename.find("lagtimes.nii.gz")])
-    return datafileroot
+    datafileroots.append(datafileroot)
+    addDataset(datafileroots[-1])
+    whichsubject = len(thesubjects) - 1
+    selectDataset(whichsubject)
+
+    # update the file menu
+    updateFileMenu()
+
+
+def selectDataset(thesubject):
+    global currentdataset, thesubjects, whichsubject, datafileroots
+    global ui, win, defaultdict, overlagGraphicsViews
+    global verbosity, uiinitialized
+
+    whichsubject = thesubject
+    if uiinitialized:
+        thesubjects[whichsubject].setfocusregressor(currentdataset.focusregressor)
+        thesubjects[whichsubject].setfocusmap(currentdataset.focusmap)
+    currentdataset = thesubjects[whichsubject]
+    activateDataset(
+        currentdataset,
+        ui,
+        win,
+        defaultdict,
+        overlayGraphicsViews,
+        verbosity=verbosity,
+    )
+
+    # update the file menu
+    updateFileMenu()
 
 
 class xyztlocation(QtWidgets.QWidget):
@@ -314,10 +421,17 @@ class xyztlocation(QtWidgets.QWidget):
         # print('resetting T spinbox values')
         if self.TPosSpinBox is not None:
             self.TPosSpinBox.setValue(self.tpos)
+            self.TPosSpinBox.setRange(0, self.tdim - 1)
         if self.TCoordSpinBox is not None:
             self.TCoordSpinBox.setValue(self.tcoord)
+            tllcoord = self.tr2real(0)
+            tulcoord = self.tr2real(self.tdim - 1)
+            tmin = np.min([tllcoord, tulcoord])
+            tmax = np.max([tllcoord, tulcoord])
+            self.TCoordSpinBox.setRange(tmin, tmax)
         if self.TimeSlider is not None:
             self.TimeSlider.setValue((self.tpos))
+            self.TimeSlider.setRange(0, self.tdim - 1)
         # print('done resetting T spinbox values')
         self.updatedT.emit()
 
@@ -349,6 +463,8 @@ class xyztlocation(QtWidgets.QWidget):
         self.updateXYZValues(emitsignal=emitsignal)
 
     def setTpos(self, tpos):
+        if tpos > self.tdim:
+            tpos = self.tdim
         if self.tpos != tpos:
             self.tpos = tpos
             self.tcoord = self.tr2real(self.tpos)
@@ -469,77 +585,7 @@ class xyztlocation(QtWidgets.QWidget):
             self.movieTimer.start(int(self.frametime))
 
 
-"""class KeyPressWindow(QtWidgets.QMainWindow):
-    sigKeyPress = QtCore.pyqtSignal(object)
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def keyPressEvent(self, ev):
-        self.sigKeyPress.emit(ev)"""
-
-
-def nextFileButtonPressed():
-    global currentdataset, thesubjects, whichsubject
-    global defaultdict, overlayGraphicsViews
-    numsubjects = len(thesubjects)
-    whichsubject = (whichsubject + 1) % numsubjects
-    print(f"subject number set to {whichsubject}")
-    thesubjects[whichsubject].setfocusregressor(currentdataset.focusregressor)
-    thesubjects[whichsubject].setfocusmap(currentdataset.focusmap)
-    currentdataset = thesubjects[whichsubject]
-    activatedataset(
-        currentdataset,
-        ui,
-        win,
-        defaultdict,
-        overlayGraphicsViews,
-        verbosity=verbosity,
-        doinit=False,
-    )
-    updateRegressor()
-    updateRegressorSpectrum()
-    updateUI(
-        callingfunc="nextFileButtonPressed",
-        orthoimages=True,
-        histogram=True,
-        focusvals=True,
-    )
-
-
-"""def keyPressed(evt):
-    global currentsubject, thesubjects, whichsubject
-    global defaultdict, overlayGraphicsViews
-    numsubjects = len(thesubjects)
-    if evt.key() == QtCore.Qt.Key.Key_F:
-        whichsubject = (whichsubject + 1) % numsubjects
-        print("Key_Up")
-    elif evt.key() == QtCore.Qt.Key.Key_B:
-        whichsubject = (whichsubject - 1) % numsubjects
-        print("Key_Down")
-    elif evt.key() == QtCore.Qt.Key.Key_Left:
-        whichsubject = (whichsubject - 1) % numsubjects
-        print("Key_Left")
-    elif evt.key() == QtCore.Qt.Key.Key_Right:
-        whichsubject = (whichsubject + 1) % numsubjects
-        print("Key_Right")
-    else:
-        print(evt.key())
-    print(f"subject number set to {whichsubject}")
-    currentdataset = thesubjects[whichsubject]
-    activatedataset(
-        currentdataset,
-        ui,
-        win,
-        defaultdict,
-        overlayGraphicsViews,
-        verbosity=verbosity,
-        doinit=False,
-    )
-    updateOrthoImages()"""
-
-
-def logstatus(thetextbox, thetext):
+def logStatus(thetextbox, thetext):
     if pyqtversion == 5:
         thetextbox.moveCursor(QtGui.QTextCursor.End)
     thetextbox.insertPlainText(thetext + "\n")
@@ -871,7 +917,7 @@ def updateAveragingMode():
     print("in updateAveragingMode")
     if ("atlas" in overlays) and (not atlasaveragingdone):
         calcAtlasStats()
-        set_atlasmask()
+        setAtlasMask()
     if ("atlas" in overlays) and False:
         updateAtlasStats()
     if averagingmode is not None:
@@ -938,7 +984,7 @@ def MAD_radioButton_clicked(enabled):
         updateAveragingMode()
 
 
-def transparency_checkbox_clicked():
+def transparencyCheckboxClicked():
     global LUT_alpha, LUT_endalpha, ui, overlays, currentdataset
     global verbosity
 
@@ -1034,7 +1080,7 @@ def rainbow_radioButton_clicked(enabled):
         updateLUT()
 
 
-def set_mask(maskname):
+def setMask(maskname):
     global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
     maskinfodicts = {}
     maskinfodicts["nomask"] = {
@@ -1049,6 +1095,10 @@ def set_mask(maskname):
         "msg": "Using valid fit points as functional mask",
         "label": "Valid mask",
     }
+    maskinfodicts["brainmask"] = {
+        "msg": "Externally provided brain mask",
+        "label": "Brain mask",
+    }
     maskinfodicts["refinemask"] = {
         "msg": "Voxel refinement mask",
         "label": "Refine mask",
@@ -1071,16 +1121,16 @@ def set_mask(maskname):
             overlays[themap].setFuncMask(overlays[maskname].data)
     atlasaveragingdone = False
     updateAveragingMode()
-    updateUI(callingfunc=f"set_mask({maskname})", orthoimages=True, histogram=True)
+    updateUI(callingfunc=f"setMask({maskname})", orthoimages=True, histogram=True)
 
 
-def set_atlasmask():
+def setAtlasMask():
     global overlays, loadedfuncmaps, ui, currentdataset
     print("Using all defined atlas regions as functional mask")
     ui.setMask_Button.setText("Valid mask")
     for themap in currentdataset.loadedfuncmaps:
         overlays[themap].setFuncMask(overlays["atlasmask"].data)
-    updateUI(callingfunc="set_atlasmask", orthoimages=True, histogram=True)
+    updateUI(callingfunc="setAtlasMask", orthoimages=True, histogram=True)
 
 
 def overlay_radioButton_clicked(which, enabled):
@@ -1096,6 +1146,8 @@ def overlay_radioButton_clicked(which, enabled):
                 currentdataset.setfocusmap(panetomap[which] + "_atlasstat")
             else:
                 currentdataset.setfocusmap(panetomap[which])
+                thedispmin = overlays[currentdataset.focusmap].dispmin
+                thedispmax = overlays[currentdataset.focusmap].dispmax
             if verbosity > 1:
                 print("currentdataset.focusmap set to ", currentdataset.focusmap)
             if overlays[currentdataset.focusmap].lut_state == gen_gray_state():
@@ -1122,7 +1174,9 @@ def overlay_radioButton_clicked(which, enabled):
                 overlays[currentdataset.focusmap].tr,
                 overlays[currentdataset.focusmap].toffset,
             )
-
+            overlays[currentdataset.focusmap].dispmin = thedispmin
+            overlays[currentdataset.focusmap].dispmax = thedispmax
+            updateDispLimits()
             updateUI(
                 callingfunc="overlay_radioButton_clicked",
                 histogram=True,
@@ -1275,7 +1329,7 @@ def printfocusvals():
     global ui, overlays, currentdataset
     global currentloc
     global simfuncFitter
-    logstatus(
+    logStatus(
         ui.logOutput,
         "\n\nValues at location "
         + "{0},{1},{2}".format(currentloc.xpos, currentloc.ypos, currentloc.zpos),
@@ -1297,7 +1351,7 @@ def printfocusvals():
                             + str(":")
                             + "{:.3f}".format(round(focusval, 3))
                         )
-                        logstatus(ui.logOutput, outstring)
+                        logStatus(ui.logOutput, outstring)
                     else:
                         if focusval > 0.0:
                             if simfuncFitter is not None:
@@ -1308,7 +1362,7 @@ def printfocusvals():
                                     + str(":\n\t    ")
                                     + failstring.replace(", ", "\n\t    ")
                                 )
-                                logstatus(ui.logOutput, outstring)
+                                logStatus(ui.logOutput, outstring)
                 else:
                     outstring = (
                         indentstring
@@ -1316,7 +1370,7 @@ def printfocusvals():
                         + str(":")
                         + str(currentdataset.atlaslabels[int(focusval) - 1])
                     )
-                    logstatus(ui.logOutput, outstring)
+                    logStatus(ui.logOutput, outstring)
 
 
 def regressor_radioButton_clicked(theregressor, enabled):
@@ -1326,15 +1380,22 @@ def regressor_radioButton_clicked(theregressor, enabled):
     updateRegressorSpectrum()
 
 
-def activatedataset(
-    currentdataset, ui, win, defaultdict, overlayGraphicsViews, verbosity=0, doinit=False
-):
+def activateDataset(currentdataset, ui, win, defaultdict, overlayGraphicsViews, verbosity=0):
     global regressors, overlays
     global mainwin
     global xdim, ydim, zdim, tdim, xpos, ypos, zpos, tpos
     global timeaxis
     global usecorrout
     global orthoimagedict
+    global panesinitialized, uiinitialized
+    global currentloc
+
+    if uiinitialized:
+        currentloc.xdim = currentdataset.xdim
+        currentloc.ydim = currentdataset.ydim
+        currentloc.xdim = currentdataset.zdim
+        currentloc.tdim = currentdataset.tdim
+        currentloc.setTpos(currentloc.tpos)
 
     if verbosity > 1:
         print("getting regressors")
@@ -1508,7 +1569,7 @@ def activatedataset(
 
     if verbosity > 1:
         print("focusmap is:", currentdataset.focusmap, "bgmap is:", bgmap)
-    if doinit:
+    if not panesinitialized:
         if bgmap is None:
             mainwin = OrthoImageItem(
                 overlays[currentdataset.focusmap],
@@ -1533,12 +1594,12 @@ def activatedataset(
     else:
         mainwin.setMap(overlays[currentdataset.focusmap])
 
-    if verbosity > 1:
-        print("loading panes")
     availablepanes = len(overlayGraphicsViews)
+    if verbosity > 0:
+        print(f"loading {availablepanes} available panes")
     numnotloaded = 0
     numloaded = 0
-    if doinit:
+    if not panesinitialized:
         orthoimagedict = {}
         for idx, themap in enumerate(currentdataset.dispmaps):
             if overlays[themap].display_state:
@@ -1546,11 +1607,15 @@ def activatedataset(
                     (numloaded > availablepanes - 2) and (themap != "corrout")
                 ):
                     if verbosity > 1:
-                        print("skipping map ", themap, "(", idx, "): out of display panes")
+                        print(
+                            f"skipping map {themap}({idx}): out of display panes ({numloaded=}, {availablepanes=})"
+                        )
                     numnotloaded += 1
                 else:
                     if verbosity > 1:
-                        print("loading map ", themap, "(", idx, ") into pane ", numloaded)
+                        print(
+                            f"loading map {themap}=({idx}) into pane {numloaded} of {availablepanes}"
+                        )
                     if bgmap is None:
                         loadpane(
                             overlays[themap],
@@ -1572,7 +1637,7 @@ def activatedataset(
                             bgmap=overlays[bgmap],
                             sm_imgsize=sm_imgsize,
                         )
-                numloaded += 1
+                    numloaded += 1
             else:
                 if verbosity > 1:
                     print("not loading map ", themap, "(", idx, "): display_state is False")
@@ -1588,6 +1653,21 @@ def activatedataset(
     if numnotloaded > 0:
         print("WARNING:", numnotloaded, "maps could not be loaded - not enough panes")
 
+    # record that we've been through once
+    panesinitialized = True
+
+    if uiinitialized:
+        # update the windows
+        updateUI(
+            callingfunc="activateDataset",
+            orthoimages=True,
+            histogram=True,
+        )
+
+        # update the regressor
+        updateRegressor()
+        updateRegressorSpectrum()
+
 
 def loadpane(
     themap,
@@ -1627,6 +1707,7 @@ def loadpane(
 def tidepool(args):
     global vLine
     global ui, win
+    global fileMenu, sel_open, sel_files
     global movierunning
     global focusmap, bgmap, focusregressor
     global maps
@@ -1643,9 +1724,10 @@ def tidepool(args):
     global imageadj
     global harvestcolormaps
     global atlasaveragingdone
-    global currentdataset, thesubjects, whichsubject
+    global currentdataset, thesubjects, whichsubject, datafileroots
     global defaultdict, overlayGraphicsViews
     global verbosity
+    global panesinitialized, uiinitialized
     global simfuncFitter
     global simfunc_ax, simfuncCurve, simfuncfitCurve, simfuncTLine, simfuncPeakMarker, simfuncCurvePoint, simfuncCaption
 
@@ -1671,6 +1753,10 @@ def tidepool(args):
     tpos = 0
     verbosity = 0
     simfuncFitter = None
+    datafileroots = []
+    panesinitialized = False
+    uiinitialized = False
+    sel_files = None
 
     if pyqtversion == 5:
         if args.uistyle == "normal":
@@ -1702,7 +1788,6 @@ def tidepool(args):
     else:
         geommaskname = None
 
-    datafileroots = []
     if args.datafileroot is not None:
         print("using ", args.datafileroot, " as the root file name list")
         datafileroots = args.datafileroot
@@ -1729,34 +1814,25 @@ def tidepool(args):
     # make the main window
     app = QtWidgets.QApplication([])
     print("setting up output window")
-    # win = KeyPressWindow()
-    # win.sigKeyPress.connect(keyPressed)
     win = QtWidgets.QMainWindow()
     ui = uiTemplate.Ui_MainWindow()
     ui.setupUi(win)
     win.show()
     win.setWindowTitle("TiDePool")
 
-    """"# create the menu bar
+    # create the menu bar
     print("creating menu bar")
     menuBar = win.menuBar()
-    fileMenu = QtWidgets.QMenu(win)
+    fileMenu = menuBar.addMenu("File")
     if pyqtversion == 5:
         qactionfunc = QtWidgets.QAction
     else:
         qactionfunc = QtGui.QAction
-    sel_open = qactionfunc("Open", win)
-    sel_open.triggered.connect(selectFile())
+    sel_open = qactionfunc("Add dataset...", win)
+    sel_open.triggered.connect(datasetPicker)
     fileMenu.addAction(sel_open)
-    win.setMenuBar(menuBar)
-    print("done creating menu bar")"""
-
-    # get inputfile root name if necessary
-    if len(datafileroots) == 0:
-        datafileroots.append(selectFile())
-    if len(datafileroots) == 0:
-        print("No input file specified - exiting.")
-        sys.exit()
+    fileMenu.addSeparator()
+    print("done creating menu bar")
 
     # wire up the ortho image windows for mouse interaction
     vb_colorbar = pg.ViewBox(enableMouse=False)
@@ -1784,6 +1860,10 @@ def tidepool(args):
     if harvestcolormaps:
         ui.largeimage_horizontalLayout.addWidget(imageadj)
 
+    if args.uistyle == "big":
+        extramaps = True
+    else:
+        extramaps = False
     defaultdict = {
         "lagmask": {
             "colormap": gen_gray_state(),
@@ -1815,6 +1895,12 @@ def tidepool(args):
             "display": False,
             "funcmask": None,
         },
+        "brainmask": {
+            "colormap": gen_gray_state(),
+            "label": "Brain mask",
+            "display": False,
+            "funcmask": None,
+        },
         "p_lt_0p050_mask": {
             "colormap": gen_gray_state(),
             "label": "p<0.05",
@@ -1890,12 +1976,42 @@ def tidepool(args):
         "MTT": {
             "colormap": gen_spectrum_state(),
             "label": "MTT",
-            "display": True,
+            "display": extramaps,
             "funcmask": "p_lt_0p050_mask",
         },
         "R2": {
             "colormap": gen_thermal_state(),
-            "label": "Fit R2",
+            "label": "GLM Fit R2",
+            "display": extramaps,
+            "funcmask": "p_lt_0p050_mask",
+        },
+        "CoV": {
+            "colormap": gen_thermal_state(),
+            "label": "Coefficient of variation",
+            "display": True,
+            "funcmask": "p_lt_0p050_mask",
+        },
+        "confoundR2": {
+            "colormap": gen_thermal_state(),
+            "label": "Confound Fit R2",
+            "display": extramaps,
+            "funcmask": "p_lt_0p050_mask",
+        },
+        "varBefore": {
+            "colormap": gen_thermal_state(),
+            "label": "LFO variance before GLM",
+            "display": extramaps,
+            "funcmask": "p_lt_0p050_mask",
+        },
+        "varAfter": {
+            "colormap": gen_thermal_state(),
+            "label": "LFO variance after GLM",
+            "display": extramaps,
+            "funcmask": "p_lt_0p050_mask",
+        },
+        "varChange": {
+            "colormap": gen_thermal_state(),
+            "label": "LFO variance decrease %",
             "display": True,
             "funcmask": "p_lt_0p050_mask",
         },
@@ -1908,7 +2024,7 @@ def tidepool(args):
         "fitNorm": {
             "colormap": gen_thermal_state(),
             "label": "fitNorm",
-            "display": True,
+            "display": False,
             "funcmask": "p_lt_0p050_mask",
         },
         "gaussout": {
@@ -1920,7 +2036,7 @@ def tidepool(args):
         "failimage": {
             "colormap": gen_spectrum_state(),
             "label": "Fit failure reason",
-            "display": False,
+            "display": extramaps,
             "funcmask": None,
         },
         "anatomic": {
@@ -1944,7 +2060,7 @@ def tidepool(args):
         "neglog10p": {
             "colormap": gen_thermal_state(),
             "label": "Correlation fit -log10p",
-            "display": False,
+            "display": extramaps,
             "funcmask": "None",
         },
         "delayoffset": {
@@ -1999,7 +2115,7 @@ def tidepool(args):
     ui.rainbow_radioButton.clicked.connect(rainbow_radioButton_clicked)
 
     # wire up the transparency checkbox
-    ui.transparency_checkBox.stateChanged.connect(transparency_checkbox_clicked)
+    ui.transparency_checkBox.stateChanged.connect(transparencyCheckboxClicked)
 
     overlaybuttons = [
         ui.overlay_radioButton_01,
@@ -2058,13 +2174,14 @@ def tidepool(args):
         theview.hide()
 
     # define things for the popup mask menu
-    popMenu = QtWidgets.QMenu(win)
+    popMaskMenu = QtWidgets.QMenu(win)
     if pyqtversion == 5:
         qactionfunc = QtWidgets.QAction
     else:
         qactionfunc = QtGui.QAction
     sel_nomask = qactionfunc("No mask", win)
     sel_lagmask = qactionfunc("Valid fit", win)
+    sel_brainmask = qactionfunc("Externally provided brain mask", win)
     sel_refinemask = qactionfunc("Voxels used in refine", win)
     sel_meanmask = qactionfunc("Voxels used in mean regressor calculation", win)
     sel_preselectmask = qactionfunc(
@@ -2075,24 +2192,38 @@ def tidepool(args):
     sel_0p005 = qactionfunc("p<0.005", win)
     sel_0p001 = qactionfunc("p<0.001", win)
 
-    sel_nomask.triggered.connect(partial(set_mask, "nomask"))
-    sel_lagmask.triggered.connect(partial(set_mask, "lagmask"))
-    sel_refinemask.triggered.connect(partial(set_mask, "refinemask"))
-    sel_meanmask.triggered.connect(partial(set_mask, "meanmask"))
-    sel_preselectmask.triggered.connect(partial(set_mask, "preselectmask"))
-    sel_0p05.triggered.connect(partial(set_mask, "p_lt_0p050_mask"))
-    sel_0p01.triggered.connect(partial(set_mask, "p_lt_0p010_mask"))
-    sel_0p005.triggered.connect(partial(set_mask, "p_lt_0p005_mask"))
-    sel_0p001.triggered.connect(partial(set_mask, "p_lt_0p001_mask"))
-    popMenu.addAction(sel_nomask)
+    sel_nomask.triggered.connect(partial(setMask, "nomask"))
+    sel_lagmask.triggered.connect(partial(setMask, "lagmask"))
+    sel_brainmask.triggered.connect(partial(setMask, "brainmask"))
+    sel_refinemask.triggered.connect(partial(setMask, "refinemask"))
+    sel_meanmask.triggered.connect(partial(setMask, "meanmask"))
+    sel_preselectmask.triggered.connect(partial(setMask, "preselectmask"))
+    sel_0p05.triggered.connect(partial(setMask, "p_lt_0p050_mask"))
+    sel_0p01.triggered.connect(partial(setMask, "p_lt_0p010_mask"))
+    sel_0p005.triggered.connect(partial(setMask, "p_lt_0p005_mask"))
+    sel_0p001.triggered.connect(partial(setMask, "p_lt_0p001_mask"))
+    popMaskMenu.addAction(sel_nomask)
     numspecial = 0
 
-    def on_context_menu(point):
+    # configure the mask selection popup menu
+    def on_mask_context_menu(point):
         # show context menu
-        popMenu.exec(ui.setMask_Button.mapToGlobal(point))
+        popMaskMenu.exec(ui.setMask_Button.mapToGlobal(point))
 
     ui.setMask_Button.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)
-    ui.setMask_Button.customContextMenuRequested.connect(on_context_menu)
+    ui.setMask_Button.customContextMenuRequested.connect(on_mask_context_menu)
+
+    # configure the file selection popup menu
+    def on_file_context_menu(point):
+        # show context menu
+        popMaskMenu.exec(ui.setFile_Button.mapToGlobal(point))
+
+    try:
+        ui.setFile_Button.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)
+        ui.setFile_Button.customContextMenuRequested.connect(on_file_context_menu)
+        setfilebuttonexists = True
+    except AttributeError:
+        setfilebuttonexists = False
 
     # wire up the regressor selection radio buttons
     regressorbuttons = [
@@ -2116,52 +2247,41 @@ def tidepool(args):
 
     # read in all the datasets
     thesubjects = []
-
-    print("loading datasets...")
-    for thisdatafileroot in datafileroots:
-        print("Loading", thisdatafileroot)
-        thissubject = RapidtideDataset(
-            "main",
-            thisdatafileroot,
-            anatname=anatname,
-            geommaskname=geommaskname,
-            userise=userise,
-            usecorrout=usecorrout,
-            useatlas=useatlas,
-            forcetr=forcetr,
-            forceoffset=forceoffset,
-            offsettime=offsettime,
-            verbose=verbosity,
-        )
-        if len(thesubjects) > 0:
-            # check to see that the dimensions match
-            dimmatch, sizematch, spacematch, affinematch = check_rt_spatialmatch(
-                thissubject, thesubjects[0]
-            )
-            if dimmatch or args.ignoredimmatch:
-                thesubjects.append(thissubject)
-            else:
-                print(f"dataset {thisdatafileroot} does not match loaded data - skipping")
-        else:
-            thesubjects.append(thissubject)
     whichsubject = 0
-    currentdataset = thesubjects[whichsubject]
-    activatedataset(
-        currentdataset,
-        ui,
-        win,
-        defaultdict,
-        overlayGraphicsViews,
-        verbosity=verbosity,
-        doinit=True,
-    )
+    if len(datafileroots) > 0:
+        print("loading prespecified datasets...")
+        for thisdatafileroot in datafileroots:
+            addDataset(
+                thisdatafileroot,
+                anatname=anatname,
+                geommaskname=geommaskname,
+                userise=userise,
+                usecorrout=usecorrout,
+                useatlas=useatlas,
+                forcetr=forcetr,
+                forceoffset=forceoffset,
+                offsettime=offsettime,
+                ignoredimmatch=args.ignoredimmatch,
+            )
+        currentdataset = thesubjects[whichsubject]
+        activateDataset(
+            currentdataset,
+            ui,
+            win,
+            defaultdict,
+            overlayGraphicsViews,
+            verbosity=verbosity,
+        )
+        # update the file menu
+        updateFileMenu()
+    else:
+        # get inputfile root name if necessary
+        datasetPicker()
 
-    for thebutton in [ui.nextFile_Button]:
-        if len(thesubjects) == 1:
-            thebutton.setDisabled(True)
-            thebutton.hide()
-        else:
-            thebutton.clicked.connect(nextFileButtonPressed)
+    # check to see that something is loaded
+    if len(thesubjects) == 0:
+        print("No input datasets specified - exiting.")
+        sys.exit()
 
     # wire up the display range controls
     ui.resetDispLimits_Button.clicked.connect(resetDispLimits)
@@ -2263,29 +2383,32 @@ def tidepool(args):
     if verbosity > 1:
         print("loadedfuncmasks", currentdataset.loadedfuncmasks)
     if len(currentdataset.loadedfuncmasks) > 0:
-        popMenu.addSeparator()
+        popMaskMenu.addSeparator()
         if "lagmask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_lagmask)
+            popMaskMenu.addAction(sel_lagmask)
+            numspecial += 1
+        if "brainmask" in currentdataset.loadedfuncmasks:
+            popMaskMenu.addAction(sel_brainmask)
             numspecial += 1
         if "refinemask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_refinemask)
+            popMaskMenu.addAction(sel_refinemask)
             numspecial += 1
         if "meanmask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_meanmask)
+            popMaskMenu.addAction(sel_meanmask)
             numspecial += 1
         if "preselectmask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_preselectmask)
+            popMaskMenu.addAction(sel_preselectmask)
             numspecial += 1
         if numspecial > 0:
-            popMenu.addSeparator()
+            popMaskMenu.addSeparator()
         if "p_lt_0p050_mask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_0p05)
+            popMaskMenu.addAction(sel_0p05)
         if "p_lt_0p010_mask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_0p01)
+            popMaskMenu.addAction(sel_0p01)
         if "p_lt_0p005_mask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_0p005)
+            popMaskMenu.addAction(sel_0p005)
         if "p_lt_0p001_mask" in currentdataset.loadedfuncmasks:
-            popMenu.addAction(sel_0p001)
+            popMaskMenu.addAction(sel_0p001)
 
     # initialize the location picker
     global currentloc
@@ -2331,5 +2454,7 @@ def tidepool(args):
 
     updateUI(callingfunc="main thread", orthoimages=True, focusvals=True)
     updateRegressor()
+    updateRegressorSpectrum()
+    uiinitialized = True
 
     QtWidgets.QApplication.instance().exec()