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

rapidtide/workflows/tidepool.py

@@ -23,19 +23,19 @@ A simple GUI for looking at the results of a rapidtide analysis
 import argparse
 import os
 import sys
+from functools import partial
 
 import numpy as np
 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 *
 from rapidtide.helper_classes import SimilarityFunctionFitter
 from rapidtide.OrthoImageItem import OrthoImageItem
-from rapidtide.RapidtideDataset import RapidtideDataset
+from rapidtide.RapidtideDataset import RapidtideDataset, check_rt_spatialmatch
 from rapidtide.workflows.atlasaverage import summarizevoxels
 
 try:
@@ -103,11 +103,12 @@ def _get_parser():
         "--maskname", help="Set geometric mask image", dest="geommaskname", default=None
     )
     parser.add_argument(
-        "--oldstyle",
-        help="Use the old style layout",
-        dest="compact",
-        action="store_false",
-        default=True,
+        "--uistyle",
+        action="store",
+        type=str,
+        choices=["normal", "old", "big"],
+        help="Set the window layout style.  Default is 'normal'.",
+        default="normal",
     )
     parser.add_argument(
         "--verbosity",
@@ -115,13 +116,99 @@ def _get_parser():
         dest="verbose",
         metavar="VERBOSITY",
         type=int,
-        default=1,
+        default=0,
+    )
+    parser.add_argument(
+        "--ignoredimmatch",
+        help="Do not check to see if dataset sizes match",
+        dest="ignoredimmatch",
+        action="store_true",
+        default=False,
     )
 
     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()
@@ -137,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):
@@ -305,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()
 
@@ -340,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)
@@ -460,48 +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 keyPressed(evt):
-    global currentsubject, thesubjects, whichsubject
-    global defaultdict, overlayGraphicsViews
-    numsubjects = len(thesubjects)
-    if evt.key() == QtCore.Qt.Key.Key_Up:
-        whichsubject = (whichsubject + 1) % numsubjects
-        print("Key_Up")
-    elif evt.key() == QtCore.Qt.Key.Key_Down:
-        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,
-    )"""
-
-
-def logstatus(thetextbox, thetext):
+def logStatus(thetextbox, thetext):
     if pyqtversion == 5:
         thetextbox.moveCursor(QtGui.QTextCursor.End)
     thetextbox.insertPlainText(thetext + "\n")
@@ -707,6 +791,8 @@ def updateRegressor():
         size = [upperlim - lowerlim, tctop - tcbottom]
         therectangle = RectangleItem(bottomleft, size)
         regressor_ax.addItem(therectangle)
+    else:
+        print("currentdataset.focusregressor is None!")
 
 
 def updateRegressorSpectrum():
@@ -831,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:
@@ -898,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
 
@@ -994,178 +1080,57 @@ def rainbow_radioButton_clicked(enabled):
         updateLUT()
 
 
-def set_atlasmask():
-    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)
-
-
-def set_lagmask():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("Using valid fit points as functional mask")
-    ui.setMask_Button.setText("Valid mask")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["lagmask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_lagmask()", orthoimages=True, histogram=True)
-
-
-def set_refinemask():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("Voxel refinement mask")
-    ui.setMask_Button.setText("Refine mask")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["refinemask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_refinemask", orthoimages=True, histogram=True)
-
-
-def set_meanmask():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("Mean regressor seed mask")
-    ui.setMask_Button.setText("Mean mask")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["meanmask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_meanmask", orthoimages=True, histogram=True)
-
-
-def set_preselectmask():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("Preselected mean regressor seed mask")
-    ui.setMask_Button.setText("Preselect mask")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["preselectmask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_preselectmask", orthoimages=True, histogram=True)
-
-
-def set_nomask():
+def setMask(maskname):
     global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("disabling functional mask")
-    ui.setMask_Button.setText("No Mask")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(None)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_nomask", orthoimages=True, histogram=True)
-
-
-def set_0p05():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("setting functional mask to p<0.05")
-    ui.setMask_Button.setText("p<0.05")
-    # overlays['jit_mask'] = tide_stats.makepmask(overlays['lagstrengths'], 0.05, sighistfit, onesided=True)
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["p_lt_0p050_mask"].data)
-        # overlays[themap].setFuncMask(overlays['jit_mask'].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_0p05", orthoimages=True, histogram=True)
-
-
-def set_0p01():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("setting functional mask to p<0.01")
-    ui.setMask_Button.setText("p<0.01")
-    for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["p_lt_0p010_mask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_0p01", orthoimages=True, histogram=True)
-
-
-def set_0p005():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("setting functional mask to p<0.005")
-    ui.setMask_Button.setText("p<0.005")
+    maskinfodicts = {}
+    maskinfodicts["nomask"] = {
+        "msg": "Disabling functional mask",
+        "label": "No mask",
+    }
+    maskinfodicts["meanmask"] = {
+        "msg": "Mean regressor seed mask",
+        "label": "Mean mask",
+    }
+    maskinfodicts["lagmask"] = {
+        "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",
+    }
+    maskinfodicts["preselectmask"] = {
+        "msg": "Preselected mean regressor seed mask",
+        "label": "Preselect mask",
+    }
+    for pval in [0.05, 0.01, 0.005, 0.001]:
+        maskinfodicts[f"p_lt_{(str(pval) + '0').replace('.','p')[0:5]}_mask"] = {
+            "msg": f"Setting functional mask to p<{str(pval)}",
+            "label": f"p<{str(pval)}",
+        }
+    print(maskinfodicts[maskname]["msg"])
+    ui.setMask_Button.setText(maskinfodicts[maskname]["label"])
     for themap in currentdataset.loadedfuncmaps:
-        overlays[themap].setFuncMask(overlays["p_lt_0p005_mask"].data)
+        if maskname == "nomask":
+            overlays[themap].setFuncMask(None)
+        else:
+            overlays[themap].setFuncMask(overlays[maskname].data)
     atlasaveragingdone = False
     updateAveragingMode()
-    updateUI(callingfunc="set_0p005", orthoimages=True, histogram=True)
+    updateUI(callingfunc=f"setMask({maskname})", orthoimages=True, histogram=True)
 
 
-def set_0p001():
-    global overlays, loadedfuncmaps, ui, atlasaveragingdone, currentdataset
-    print("setting functional mask to p<0.001")
-    ui.setMask_Button.setText("p<0.001")
+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["p_lt_0p001_mask"].data)
-    atlasaveragingdone = False
-    updateAveragingMode()
-    updateUI(callingfunc="set_0p001", orthoimages=True, histogram=True)
-
-
-def overlay_radioButton_01_clicked(enabled):
-    overlay_radioButton_clicked(0, enabled)
-
-
-def overlay_radioButton_02_clicked(enabled):
-    overlay_radioButton_clicked(1, enabled)
-
-
-def overlay_radioButton_03_clicked(enabled):
-    overlay_radioButton_clicked(2, enabled)
-
-
-def overlay_radioButton_04_clicked(enabled):
-    overlay_radioButton_clicked(3, enabled)
-
-
-def overlay_radioButton_05_clicked(enabled):
-    overlay_radioButton_clicked(4, enabled)
-
-
-def overlay_radioButton_06_clicked(enabled):
-    overlay_radioButton_clicked(5, enabled)
-
-
-def overlay_radioButton_07_clicked(enabled):
-    overlay_radioButton_clicked(6, enabled)
-
-
-def overlay_radioButton_08_clicked(enabled):
-    overlay_radioButton_clicked(7, enabled)
-
-
-def overlay_radioButton_09_clicked(enabled):
-    overlay_radioButton_clicked(8, enabled)
-
-
-def overlay_radioButton_10_clicked(enabled):
-    overlay_radioButton_clicked(9, enabled)
-
-
-def overlay_radioButton_11_clicked(enabled):
-    overlay_radioButton_clicked(10, enabled)
-
-
-def overlay_radioButton_12_clicked(enabled):
-    overlay_radioButton_clicked(11, enabled)
-
-
-def overlay_radioButton_13_clicked(enabled):
-    overlay_radioButton_clicked(12, enabled)
-
-
-def overlay_radioButton_14_clicked(enabled):
-    overlay_radioButton_clicked(13, enabled)
-
-
-def overlay_radioButton_15_clicked(enabled):
-    overlay_radioButton_clicked(14, enabled)
-
-
-def overlay_radioButton_16_clicked(enabled):
-    overlay_radioButton_clicked(15, enabled)
+        overlays[themap].setFuncMask(overlays["atlasmask"].data)
+    updateUI(callingfunc="setAtlasMask", orthoimages=True, histogram=True)
 
 
 def overlay_radioButton_clicked(which, enabled):
@@ -1181,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():
@@ -1207,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,
@@ -1360,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),
@@ -1382,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:
@@ -1393,7 +1362,7 @@ def printfocusvals():
                                     + str(":\n\t    ")
                                     + failstring.replace(", ", "\n\t    ")
                                 )
-                                logstatus(ui.logOutput, outstring)
+                                logStatus(ui.logOutput, outstring)
                 else:
                     outstring = (
                         indentstring
@@ -1401,65 +1370,39 @@ def printfocusvals():
                         + str(":")
                         + str(currentdataset.atlaslabels[int(focusval) - 1])
                     )
-                    logstatus(ui.logOutput, outstring)
-
-
-def prefilt_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("prefilt")
-    updateRegressor()
-    updateRegressorSpectrum()
+                    logStatus(ui.logOutput, outstring)
 
 
-def postfilt_radioButton_clicked(enabled):
+def regressor_radioButton_clicked(theregressor, enabled):
     global currentdataset
-    currentdataset.setfocusregressor("postfilt")
+    currentdataset.setfocusregressor(theregressor)
     updateRegressor()
     updateRegressorSpectrum()
 
 
-def pass1_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass1")
-    updateRegressor()
-    updateRegressorSpectrum()
-
-
-def pass2_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass2")
-    updateRegressor()
-    updateRegressorSpectrum()
-
-
-def pass3_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass3")
-    updateRegressor()
-    updateRegressorSpectrum()
-
-
-def pass4_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass4")
-    updateRegressor()
-    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)
 
-    print("getting regressors")
+    if verbosity > 1:
+        print("getting regressors")
     regressors = currentdataset.getregressors()
 
-    print("getting overlays")
+    if verbosity > 1:
+        print("getting overlays")
     overlays = currentdataset.getoverlays()
     try:
         test = overlays["corrout"].display_state
@@ -1467,7 +1410,8 @@ def activatedataset(
         usecorrout = False
 
     # activate the appropriate regressor radio buttons
-    print("activating radio buttons")
+    if verbosity > 1:
+        print("activating radio buttons")
     if "prefilt" in regressors.keys():
         ui.prefilt_radioButton.setDisabled(False)
         ui.prefilt_radioButton.show()
@@ -1530,7 +1474,8 @@ def activatedataset(
         bgmap = None
 
     # set up the timecourse plot window
-    print("setting up timecourse plot window")
+    if verbosity > 1:
+        print("setting up timecourse plot window")
     xpos = int(currentdataset.xdim) // 2
     ypos = int(currentdataset.ydim) // 2
     zpos = int(currentdataset.zdim) // 2
@@ -1557,7 +1502,8 @@ def activatedataset(
     tpos = 0
 
     # set position and scale of images
-    print("setting position and scale of images")
+    if verbosity > 1:
+        print("setting position and scale of images")
     lg_imgsize = 256.0
     sm_imgsize = 32.0
     xfov = currentdataset.xdim * currentdataset.xsize
@@ -1623,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],
@@ -1648,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:
@@ -1661,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],
@@ -1687,17 +1637,37 @@ 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")
     else:
-        print(orthoimagedict)
+        for thismap in panetomap:
+            if thismap != "":
+                try:
+                    orthoimagedict[thismap].setMap(overlays[thismap])
+                except KeyError:
+                    pass
     if verbosity > 1:
         print("done loading panes")
     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,
@@ -1737,8 +1707,9 @@ def loadpane(
 def tidepool(args):
     global vLine
     global ui, win
+    global fileMenu, sel_open, sel_files
     global movierunning
-    global focusmap, bgmap
+    global focusmap, bgmap, focusregressor
     global maps
     global roi
     global overlays, regressors, regressorfilterlimits, regressorsimcalclimits, loadedfuncmaps, atlasstats, averagingmode
@@ -1753,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
 
@@ -1781,15 +1753,23 @@ def tidepool(args):
     tpos = 0
     verbosity = 0
     simfuncFitter = None
+    datafileroots = []
+    panesinitialized = False
+    uiinitialized = False
+    sel_files = None
 
     if pyqtversion == 5:
-        if args.compact:
+        if args.uistyle == "normal":
             import rapidtide.tidepoolTemplate_alt as uiTemplate
+        elif args.uistyle == "big":
+            import rapidtide.tidepoolTemplate_big as uiTemplate
         else:
             import rapidtide.tidepoolTemplate as uiTemplate
     else:
-        if args.compact:
+        if args.uistyle == "normal":
             import rapidtide.tidepoolTemplate_alt_qt6 as uiTemplate
+        elif args.uistyle == "big":
+            import rapidtide.tidepoolTemplate_big_qt6 as uiTemplate
         else:
             import rapidtide.tidepoolTemplate_qt6 as uiTemplate
 
@@ -1808,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
@@ -1835,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()
+    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)
@@ -1890,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(),
@@ -1921,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",
@@ -1996,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",
         },
@@ -2014,7 +2024,7 @@ def tidepool(args):
         "fitNorm": {
             "colormap": gen_thermal_state(),
             "label": "fitNorm",
-            "display": True,
+            "display": False,
             "funcmask": "p_lt_0p050_mask",
         },
         "gaussout": {
@@ -2026,7 +2036,7 @@ def tidepool(args):
         "failimage": {
             "colormap": gen_spectrum_state(),
             "label": "Fit failure reason",
-            "display": False,
+            "display": extramaps,
             "funcmask": None,
         },
         "anatomic": {
@@ -2050,7 +2060,7 @@ def tidepool(args):
         "neglog10p": {
             "colormap": gen_thermal_state(),
             "label": "Correlation fit -log10p",
-            "display": False,
+            "display": extramaps,
             "funcmask": "None",
         },
         "delayoffset": {
@@ -2105,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,
@@ -2117,8 +2127,19 @@ def tidepool(args):
         ui.overlay_radioButton_07,
         ui.overlay_radioButton_08,
     ]
+    if args.uistyle == "big":
+        overlaybuttons += [
+            ui.overlay_radioButton_09,
+            ui.overlay_radioButton_10,
+            ui.overlay_radioButton_11,
+            ui.overlay_radioButton_12,
+            ui.overlay_radioButton_13,
+            ui.overlay_radioButton_14,
+            ui.overlay_radioButton_15,
+            ui.overlay_radioButton_16,
+        ]
     for i in range(len(overlaybuttons)):
-        clickfunc = globals()[f"overlay_radioButton_{str(i + 1).zfill(2)}_clicked"]
+        clickfunc = partial(overlay_radioButton_clicked, i)
         overlaybuttons[i].clicked.connect(clickfunc)
 
     for button in overlaybuttons:
@@ -2135,7 +2156,17 @@ def tidepool(args):
         ui.overlay_graphicsView_07,
         ui.overlay_graphicsView_08,
     ]
-
+    if args.uistyle == "big":
+        overlayGraphicsViews += [
+            ui.overlay_graphicsView_09,
+            ui.overlay_graphicsView_10,
+            ui.overlay_graphicsView_11,
+            ui.overlay_graphicsView_12,
+            ui.overlay_graphicsView_13,
+            ui.overlay_graphicsView_14,
+            ui.overlay_graphicsView_15,
+            ui.overlay_graphicsView_16,
+        ]
     panetomap = []
 
     for theview in overlayGraphicsViews:
@@ -2143,40 +2174,56 @@ 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_nomask.triggered.connect(set_nomask)
     sel_lagmask = qactionfunc("Valid fit", win)
-    sel_lagmask.triggered.connect(set_lagmask)
+    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(
         "Voxels chosen for the mean regressor calculation in the preselect pass", win
     )
-    sel_refinemask.triggered.connect(set_refinemask)
-    sel_meanmask.triggered.connect(set_meanmask)
-    sel_preselectmask.triggered.connect(set_preselectmask)
     sel_0p05 = qactionfunc("p<0.05", win)
-    sel_0p05.triggered.connect(set_0p05)
     sel_0p01 = qactionfunc("p<0.01", win)
-    sel_0p01.triggered.connect(set_0p01)
     sel_0p005 = qactionfunc("p<0.005", win)
-    sel_0p005.triggered.connect(set_0p005)
     sel_0p001 = qactionfunc("p<0.001", win)
-    sel_0p001.triggered.connect(set_0p001)
-    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 = [
@@ -2187,13 +2234,12 @@ def tidepool(args):
         ui.pass3_radioButton,
         ui.pass4_radioButton,
     ]
-
-    ui.prefilt_radioButton.clicked.connect(prefilt_radioButton_clicked)
-    ui.postfilt_radioButton.clicked.connect(postfilt_radioButton_clicked)
-    ui.pass1_radioButton.clicked.connect(pass1_radioButton_clicked)
-    ui.pass2_radioButton.clicked.connect(pass2_radioButton_clicked)
-    ui.pass3_radioButton.clicked.connect(pass3_radioButton_clicked)
-    ui.pass4_radioButton.clicked.connect(pass4_radioButton_clicked)
+    ui.prefilt_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "prefilt"))
+    ui.postfilt_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "postfilt"))
+    ui.pass1_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "pass1"))
+    ui.pass2_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "pass2"))
+    ui.pass3_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "pass3"))
+    ui.pass4_radioButton.clicked.connect(partial(regressor_radioButton_clicked, "pass4"))
 
     for thebutton in regressorbuttons:
         thebutton.setDisabled(True)
@@ -2201,38 +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
-            pass
-        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()
+
+    # 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)
@@ -2334,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
@@ -2395,12 +2447,14 @@ def tidepool(args):
     # timecourse_ax.enableAutoRange()
 
     # select the first pane
-    overlay_radioButton_01_clicked(True)
+    overlay_radioButton_clicked(0, True)
 
     # have to do this after the windows are created
     imageadj.sigGradientChanged.connect(updateLUT)
 
     updateUI(callingfunc="main thread", orthoimages=True, focusvals=True)
     updateRegressor()
+    updateRegressorSpectrum()
+    uiinitialized = True
 
     QtWidgets.QApplication.instance().exec()