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

rapidtide/workflows/tidepool.py

@@ -23,6 +23,7 @@ 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
@@ -35,7 +36,7 @@ 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:
@@ -85,7 +86,11 @@ def _get_parser():
     )
     parser.add_argument(
         "--dataset",
-        help="Use this dataset (skip initial selection step)",
+        nargs="*",
+        help=(
+            "Use this dataset root name (skip initial selection step).  The root name is the entire path "
+            "to the rapidtide output data (including the underscore) that precedes 'desc-maxtime_map.nii.gz'"
+        ),
         dest="datafileroot",
         default=None,
     )
@@ -99,11 +104,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",
@@ -111,14 +117,20 @@ 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():
-    global datafileroot
     mydialog = QtWidgets.QFileDialog()
     if pyqtversion == 5:
         options = mydialog.Options()
@@ -134,6 +146,7 @@ def selectFile():
         datafileroot = str(lagfilename[:bidsstartloc])
     else:
         datafileroot = str(lagfilename[: lagfilename.find("lagtimes.nii.gz")])
+    return datafileroot
 
 
 class xyztlocation(QtWidgets.QWidget):
@@ -456,6 +469,76 @@ 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):
     if pyqtversion == 5:
         thetextbox.moveCursor(QtGui.QTextCursor.End)
@@ -662,6 +745,8 @@ def updateRegressor():
         size = [upperlim - lowerlim, tctop - tcbottom]
         therectangle = RectangleItem(bottomleft, size)
         regressor_ax.addItem(therectangle)
+    else:
+        print("currentdataset.focusregressor is None!")
 
 
 def updateRegressorSpectrum():
@@ -695,7 +780,7 @@ def updateRegressorSpectrum():
 
 
 def calcAtlasStats():
-    global overlays, datafileroot, atlasstats, averagingmode, currentdataset
+    global overlays, atlasstats, averagingmode, currentdataset
     global atlasaveragingdone
     print("in calcAtlasStats")
     methodlist = ["mean", "median", "std", "MAD", "CoV"]
@@ -742,7 +827,7 @@ def calcAtlasStats():
             df = pd.DataFrame(data=d)
             df = df[cols]
             df.to_csv(
-                datafileroot + currentdataset.atlasname + "_" + thestat + ".txt",
+                currentdataset.fileroot + currentdataset.atlasname + "_" + thestat + ".txt",
                 sep="\t",
                 index=False,
             )
@@ -752,7 +837,7 @@ def calcAtlasStats():
 
 
 def updateAtlasStats():
-    global overlays, datafileroot, atlasstats, averagingmode, currentdataset
+    global overlays, atlasstats, averagingmode, currentdataset
     print("in updateAtlasStats")
     if "atlas" in overlays and (averagingmode is not None):
         for idx, themap in enumerate(currentdataset.loadedfuncmaps):
@@ -949,146 +1034,53 @@ 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():
-    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():
+def set_mask(maskname):
     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["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"set_mask({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 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["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)
+        overlays[themap].setFuncMask(overlays["atlasmask"].data)
+    updateUI(callingfunc="set_atlasmask", orthoimages=True, histogram=True)
 
 
 def overlay_radioButton_clicked(which, enabled):
@@ -1261,7 +1253,7 @@ def updateOrthoImages():
     global maps
     global panetomap
     global ui
-    global mainwin, orthoimages
+    global mainwin, orthoimagedict
     global currentloc
     # global updateTimecoursePlot
     global xdim, ydim, zdim
@@ -1270,8 +1262,8 @@ def updateOrthoImages():
 
     for thismap in panetomap:
         if thismap != "":
-            orthoimages[thismap].setXYZpos(currentloc.xpos, currentloc.ypos, currentloc.zpos)
-            orthoimages[thismap].setTpos(currentloc.tpos)
+            orthoimagedict[thismap].setXYZpos(currentloc.xpos, currentloc.ypos, currentloc.zpos)
+            orthoimagedict[thismap].setTpos(currentloc.tpos)
     mainwin.setMap(overlays[currentdataset.focusmap])
     mainwin.setTpos(currentloc.tpos)
     mainwin.updateAllViews()
@@ -1288,6 +1280,7 @@ def printfocusvals():
         "\n\nValues at location "
         + "{0},{1},{2}".format(currentloc.xpos, currentloc.ypos, currentloc.zpos),
     )
+    indentstring = "   "
     for key in overlays:
         # print(key, overlays[key].report)
         if key != "mnibrainmask":
@@ -1299,7 +1292,7 @@ def printfocusvals():
                 if key != "atlas":
                     if key != "failimage":
                         outstring = (
-                            "\t"
+                            indentstring
                             + str(overlays[key].label.ljust(26))
                             + str(":")
                             + "{:.3f}".format(round(focusval, 3))
@@ -1310,7 +1303,7 @@ def printfocusvals():
                             if simfuncFitter is not None:
                                 failstring = simfuncFitter.diagnosefail(np.uint32(focusval))
                                 outstring = (
-                                    "\t"
+                                    indentstring
                                     + str(overlays[key].label.ljust(26))
                                     + str(":\n\t    ")
                                     + failstring.replace(", ", "\n\t    ")
@@ -1318,7 +1311,7 @@ def printfocusvals():
                                 logstatus(ui.logOutput, outstring)
                 else:
                     outstring = (
-                        "\t"
+                        indentstring
                         + str(overlays[key].label.ljust(26))
                         + str(":")
                         + str(currentdataset.atlaslabels[int(focusval) - 1])
@@ -1326,68 +1319,332 @@ def printfocusvals():
                     logstatus(ui.logOutput, outstring)
 
 
-def prefilt_radioButton_clicked(enabled):
+def regressor_radioButton_clicked(theregressor, enabled):
     global currentdataset
-    currentdataset.setfocusregressor("prefilt")
+    currentdataset.setfocusregressor(theregressor)
     updateRegressor()
     updateRegressorSpectrum()
 
 
-def postfilt_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("postfilt")
-    updateRegressor()
-    updateRegressorSpectrum()
+def activatedataset(
+    currentdataset, ui, win, defaultdict, overlayGraphicsViews, verbosity=0, doinit=False
+):
+    global regressors, overlays
+    global mainwin
+    global xdim, ydim, zdim, tdim, xpos, ypos, zpos, tpos
+    global timeaxis
+    global usecorrout
+    global orthoimagedict
 
+    if verbosity > 1:
+        print("getting regressors")
+    regressors = currentdataset.getregressors()
 
-def pass1_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass1")
-    updateRegressor()
-    updateRegressorSpectrum()
+    if verbosity > 1:
+        print("getting overlays")
+    overlays = currentdataset.getoverlays()
+    try:
+        test = overlays["corrout"].display_state
+    except KeyError:
+        usecorrout = False
 
+    # activate the appropriate regressor radio buttons
+    if verbosity > 1:
+        print("activating radio buttons")
+    if "prefilt" in regressors.keys():
+        ui.prefilt_radioButton.setDisabled(False)
+        ui.prefilt_radioButton.show()
+    else:
+        ui.prefilt_radioButton.setDisabled(True)
+        ui.prefilt_radioButton.hide()
+    if "postfilt" in regressors.keys():
+        ui.postfilt_radioButton.setDisabled(False)
+        ui.postfilt_radioButton.show()
+    else:
+        ui.postfilt_radioButton.setDisabled(True)
+        ui.postfilt_radioButton.hide()
+    if "pass1" in regressors.keys():
+        ui.pass1_radioButton.setDisabled(False)
+        ui.pass1_radioButton.show()
+    else:
+        ui.pass1_radioButton.setDisabled(True)
+        ui.pass1_radioButton.hide()
+    if "pass2" in regressors.keys():
+        ui.pass2_radioButton.setDisabled(False)
+        ui.pass2_radioButton.show()
+    else:
+        ui.pass2_radioButton.setDisabled(True)
+        ui.pass2_radioButton.hide()
+    if "pass3" in regressors.keys():
+        ui.pass3_radioButton.setDisabled(False)
+        ui.pass3_radioButton.setText("Pass " + regressors["pass3"].label[4:])
+        ui.pass3_radioButton.show()
+    else:
+        ui.pass3_radioButton.setDisabled(True)
+        ui.pass3_radioButton.setText("")
+        ui.pass3_radioButton.hide()
+    if "pass4" in regressors.keys():
+        ui.pass4_radioButton.setDisabled(False)
+        ui.pass4_radioButton.setText("Pass " + regressors["pass4"].label[4:])
+        ui.pass4_radioButton.show()
+    else:
+        ui.pass4_radioButton.setDisabled(True)
+        ui.pass4_radioButton.setText("")
+        ui.pass4_radioButton.hide()
 
-def pass2_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass2")
-    updateRegressor()
-    updateRegressorSpectrum()
+    win.setWindowTitle("TiDePool - " + currentdataset.fileroot[:-1])
 
+    # read in the significance distribution
+    if os.path.isfile(currentdataset.fileroot + "sigfit.txt"):
+        sighistfitname = currentdataset.fileroot + "sigfit.txt"
+    else:
+        sighistfitname = None
 
-def pass3_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass3")
-    updateRegressor()
-    updateRegressorSpectrum()
+    #  This is currently very broken, so it's disabled
+    # if sighistfitname is not None:
+    #    thepcts = np.array([0.95, 0.99, 0.995, 0.999])
+    #    thervals = tide_stats.rfromp(sighistfitname, thepcts)
+    #    tide_stats.printthresholds(thepcts, thervals, 'Crosscorrelation significance thresholds from data:')
 
+    # set the background image
+    if "anatomic" in overlays:
+        bgmap = "anatomic"
+    else:
+        bgmap = None
 
-def pass4_radioButton_clicked(enabled):
-    global currentdataset
-    currentdataset.setfocusregressor("pass4")
-    updateRegressor()
-    updateRegressorSpectrum()
+    # set up the 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
+    if usecorrout:
+        timeaxis = (
+            np.linspace(
+                0.0,
+                overlays["corrout"].tdim * overlays["corrout"].tr,
+                num=overlays["corrout"].tdim,
+                endpoint=False,
+            )
+            + overlays["corrout"].toffset
+        )
+    else:
+        timeaxis = (
+            np.linspace(
+                0.0,
+                overlays[currentdataset.focusmap].tdim * overlays[currentdataset.focusmap].tr,
+                num=overlays[currentdataset.focusmap].tdim,
+                endpoint=False,
+            )
+            + overlays[currentdataset.focusmap].toffset
+        )
+    tpos = 0
+
+    # set 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
+    yfov = currentdataset.ydim * currentdataset.ysize
+    zfov = currentdataset.zdim * currentdataset.zsize
+    maxfov = np.max([xfov, yfov, zfov])
+    # scalefacx = (lg_imgsize / maxfov) * currentdataset.xsize
+    # scalefacy = (lg_imgsize / maxfov) * currentdataset.ysize
+    # scalefacz = (lg_imgsize / maxfov) * currentdataset.zsize
+
+    if verbosity > 1:
+        print("setting overlay defaults")
+    for themap in currentdataset.allloadedmaps + currentdataset.loadedfuncmasks:
+        overlays[themap].setLUT(
+            defaultdict[themap]["colormap"], alpha=LUT_alpha, endalpha=LUT_endalpha
+        )
+        overlays[themap].setisdisplayed(defaultdict[themap]["display"])
+        overlays[themap].setLabel(defaultdict[themap]["label"])
+    if verbosity > 1:
+        print("done setting overlay defaults")
+
+    if verbosity > 1:
+        print("setting geometric masks")
+    if "geommask" in overlays:
+        thegeommask = overlays["geommask"].data
+        if verbosity > 1:
+            print("setting geometric mask")
+    else:
+        thegeommask = None
+        if verbosity > 1:
+            print("setting geometric mask to None")
+
+    for theoverlay in currentdataset.loadedfuncmaps:
+        overlays[theoverlay].setGeomMask(thegeommask)
+    if verbosity > 1:
+        print("done setting geometric masks")
+
+    if verbosity > 1:
+        print("setting functional masks")
+        print(currentdataset.loadedfuncmaps)
+    for theoverlay in currentdataset.loadedfuncmaps:
+        if theoverlay != "failimage":
+            if "p_lt_0p050_mask" in overlays and False:  # disable this BBF 2/8/18
+                overlays[theoverlay].setFuncMask(overlays["p_lt_0p050_mask"].data)
+                ui.setMask_Button.setText("p<0.05")
+            else:
+                overlays[theoverlay].setFuncMask(overlays["lagmask"].data)
+                ui.setMask_Button.setText("Valid mask")
+    if verbosity > 1:
+        print("done setting functional masks")
+
+    if "anatomic" in overlays:
+        overlays["anatomic"].setFuncMask(None)
+        overlays["anatomic"].setGeomMask(None)
+
+    if "atlas" in overlays:
+        overlays["atlas"].setGeomMask(thegeommask)
+        overlays["atlas"].setFuncMask(overlays["atlasmask"].data)
+
+    if verbosity > 0:
+        for theoverlay in overlays:
+            overlays[theoverlay].summarize()
+
+    if verbosity > 1:
+        print("focusmap is:", currentdataset.focusmap, "bgmap is:", bgmap)
+    if doinit:
+        if bgmap is None:
+            mainwin = OrthoImageItem(
+                overlays[currentdataset.focusmap],
+                ui.main_graphicsView_ax,
+                ui.main_graphicsView_cor,
+                ui.main_graphicsView_sag,
+                imgsize=lg_imgsize,
+                enableMouse=True,
+                verbose=verbosity,
+            )
+        else:
+            mainwin = OrthoImageItem(
+                overlays[currentdataset.focusmap],
+                ui.main_graphicsView_ax,
+                ui.main_graphicsView_cor,
+                ui.main_graphicsView_sag,
+                bgmap=overlays[bgmap],
+                imgsize=lg_imgsize,
+                enableMouse=True,
+                verbose=verbosity,
+            )
+    else:
+        mainwin.setMap(overlays[currentdataset.focusmap])
+
+    if verbosity > 1:
+        print("loading panes")
+    availablepanes = len(overlayGraphicsViews)
+    numnotloaded = 0
+    numloaded = 0
+    if doinit:
+        orthoimagedict = {}
+        for idx, themap in enumerate(currentdataset.dispmaps):
+            if overlays[themap].display_state:
+                if (numloaded > availablepanes - 1) or (
+                    (numloaded > availablepanes - 2) and (themap != "corrout")
+                ):
+                    if verbosity > 1:
+                        print("skipping map ", themap, "(", idx, "): out of display panes")
+                    numnotloaded += 1
+                else:
+                    if verbosity > 1:
+                        print("loading map ", themap, "(", idx, ") into pane ", numloaded)
+                    if bgmap is None:
+                        loadpane(
+                            overlays[themap],
+                            numloaded,
+                            overlayGraphicsViews,
+                            overlaybuttons,
+                            panetomap,
+                            orthoimagedict,
+                            sm_imgsize=sm_imgsize,
+                        )
+                    else:
+                        loadpane(
+                            overlays[themap],
+                            numloaded,
+                            overlayGraphicsViews,
+                            overlaybuttons,
+                            panetomap,
+                            orthoimagedict,
+                            bgmap=overlays[bgmap],
+                            sm_imgsize=sm_imgsize,
+                        )
+                numloaded += 1
+            else:
+                if verbosity > 1:
+                    print("not loading map ", themap, "(", idx, "): display_state is False")
+    else:
+        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")
+
+
+def loadpane(
+    themap,
+    thepane,
+    view,
+    button,
+    panemap,
+    orthoimagedict,
+    bgmap=None,
+    sm_imgsize=32.0,
+):
+    if themap.display_state:
+        if bgmap is None:
+            orthoimagedict[themap.name] = OrthoImageItem(
+                themap,
+                view[thepane],
+                view[thepane],
+                view[thepane],
+                button=button[thepane],
+                imgsize=sm_imgsize,
+                verbose=verbosity,
+            )
+        else:
+            orthoimagedict[themap.name] = OrthoImageItem(
+                themap,
+                view[thepane],
+                view[thepane],
+                view[thepane],
+                button=button[thepane],
+                bgmap=bgmap,
+                imgsize=sm_imgsize,
+                verbose=verbosity,
+            )
+        panemap[thepane] = themap.name
 
 
 def tidepool(args):
     global vLine
     global ui, win
     global movierunning
-    global focusmap, bgmap
+    global focusmap, bgmap, focusregressor
     global maps
     global roi
     global overlays, regressors, regressorfilterlimits, regressorsimcalclimits, loadedfuncmaps, atlasstats, averagingmode
-    global mainwin, orthoimages, overlaybuttons, panetomap
+    global mainwin, orthoimagedict, overlaybuttons, panetomap
     global img_colorbar, LUT_alpha, LUT_endalpha
     global lg_imgsize, scalefacx, scalefacy, scalefacz
     global xdim, ydim, zdim, tdim, xpos, ypos, zpos, tpos
     global xsize, ysize, zsize, tr
     global timeaxis
+    global usecorrout
     global buttonisdown
     global imageadj
     global harvestcolormaps
-    global datafileroot
     global atlasaveragingdone
-    global currentdataset
+    global currentdataset, thesubjects, whichsubject
+    global defaultdict, overlayGraphicsViews
     global verbosity
     global simfuncFitter
     global simfunc_ax, simfuncCurve, simfuncfitCurve, simfuncTLine, simfuncPeakMarker, simfuncCurvePoint, simfuncCaption
@@ -1416,18 +1673,22 @@ def tidepool(args):
     simfuncFitter = 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
 
     verbosity = args.verbose
-    print(f"verbosity: {args.verbose}")
+    print(f"verbosity: {verbosity}")
 
     anatname = args.anatname
     if anatname is not None:
@@ -1441,11 +1702,10 @@ def tidepool(args):
     else:
         geommaskname = None
 
-    datafileroot = args.datafileroot
-    if datafileroot is not None:
-        print("using ", datafileroot, " as the root file name ")
-    else:
-        datafileroot = ""
+    datafileroots = []
+    if args.datafileroot is not None:
+        print("using ", args.datafileroot, " as the root file name list")
+        datafileroots = args.datafileroot
 
     if args.offsettime is not None:
         forceoffset = True
@@ -1469,16 +1729,32 @@ 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
+    print("creating menu bar")
+    menuBar = win.menuBar()
+    fileMenu = QtWidgets.QMenu(win)
+    if pyqtversion == 5:
+        qactionfunc = QtWidgets.QAction
+    else:
+        qactionfunc = QtGui.QAction
+    sel_open = qactionfunc("Open", win)
+    sel_open.triggered.connect(selectFile())
+    fileMenu.addAction(sel_open)
+    win.setMenuBar(menuBar)
+    print("done creating menu bar")"""
+
     # get inputfile root name if necessary
-    if datafileroot == "":
-        selectFile()
-    if datafileroot == "":
+    if len(datafileroots) == 0:
+        datafileroots.append(selectFile())
+    if len(datafileroots) == 0:
         print("No input file specified - exiting.")
         sys.exit()
 
@@ -1583,13 +1859,13 @@ def tidepool(args):
         },
         "lagtimes": {
             "colormap": gen_viridis_state(),
-            "label": "Lag times",
+            "label": "Lag time",
             "display": True,
             "funcmask": "p_lt_0p050_mask",
         },
         "lagtimesrefined": {
             "colormap": gen_viridis_state(),
-            "label": "Refineed lag times",
+            "label": "Refined lag time",
             "display": True,
             "funcmask": "p_lt_0p050_mask",
         },
@@ -1619,7 +1895,7 @@ def tidepool(args):
         },
         "R2": {
             "colormap": gen_thermal_state(),
-            "label": "R2",
+            "label": "Fit R2",
             "display": True,
             "funcmask": "p_lt_0p050_mask",
         },
@@ -1667,8 +1943,8 @@ def tidepool(args):
         },
         "neglog10p": {
             "colormap": gen_thermal_state(),
-            "label": "Correlation fit significance",
-            "display": True,
+            "label": "Correlation fit -log10p",
+            "display": False,
             "funcmask": "None",
         },
         "delayoffset": {
@@ -1735,14 +2011,21 @@ def tidepool(args):
         ui.overlay_radioButton_07,
         ui.overlay_radioButton_08,
     ]
-    overlaybuttons[0].clicked.connect(overlay_radioButton_01_clicked)
-    overlaybuttons[1].clicked.connect(overlay_radioButton_02_clicked)
-    overlaybuttons[2].clicked.connect(overlay_radioButton_03_clicked)
-    overlaybuttons[3].clicked.connect(overlay_radioButton_04_clicked)
-    overlaybuttons[4].clicked.connect(overlay_radioButton_05_clicked)
-    overlaybuttons[5].clicked.connect(overlay_radioButton_06_clicked)
-    overlaybuttons[6].clicked.connect(overlay_radioButton_07_clicked)
-    overlaybuttons[7].clicked.connect(overlay_radioButton_08_clicked)
+    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 = partial(overlay_radioButton_clicked, i)
+        overlaybuttons[i].clicked.connect(clickfunc)
+
     for button in overlaybuttons:
         button.setDisabled(True)
         button.hide()
@@ -1757,7 +2040,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:
@@ -1771,25 +2064,26 @@ def tidepool(args):
     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_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)
+
+    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)
     numspecial = 0
 
@@ -1809,13 +2103,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)
@@ -1824,10 +2117,12 @@ def tidepool(args):
     # read in all the datasets
     thesubjects = []
 
-    thesubjects.append(
-        RapidtideDataset(
+    print("loading datasets...")
+    for thisdatafileroot in datafileroots:
+        print("Loading", thisdatafileroot)
+        thissubject = RapidtideDataset(
             "main",
-            datafileroot,
+            thisdatafileroot,
             anatname=anatname,
             geommaskname=geommaskname,
             userise=userise,
@@ -1836,250 +2131,37 @@ def tidepool(args):
             forcetr=forcetr,
             forceoffset=forceoffset,
             offsettime=offsettime,
-            verbose=args.verbose,
-        )
-    )
-    currentdataset = thesubjects[-1]
-    print("loading datasets...")
-
-    print("getting regressors")
-    regressors = currentdataset.getregressors()
-
-    print("getting overlays")
-    overlays = currentdataset.getoverlays()
-    try:
-        test = overlays["corrout"].display_state
-    except KeyError:
-        usecorrout = False
-
-    # activate the appropriate regressor radio buttons
-    print("activating radio buttons")
-    if "prefilt" in regressors.keys():
-        ui.prefilt_radioButton.setDisabled(False)
-        ui.prefilt_radioButton.show()
-    if "postfilt" in regressors.keys():
-        ui.postfilt_radioButton.setDisabled(False)
-        ui.postfilt_radioButton.show()
-    if "pass1" in regressors.keys():
-        ui.pass1_radioButton.setDisabled(False)
-        ui.pass1_radioButton.show()
-    if "pass2" in regressors.keys():
-        ui.pass2_radioButton.setDisabled(False)
-        ui.pass2_radioButton.show()
-    if "pass3" in regressors.keys():
-        ui.pass3_radioButton.setDisabled(False)
-        ui.pass3_radioButton.setText("Pass " + regressors["pass3"].label[4:])
-        ui.pass3_radioButton.show()
-    if "pass4" in regressors.keys():
-        ui.pass4_radioButton.setDisabled(False)
-        ui.pass4_radioButton.setText("Pass " + regressors["pass4"].label[4:])
-        ui.pass4_radioButton.show()
-
-    win.setWindowTitle("TiDePool - " + datafileroot[:-1])
-
-    # read in the significance distribution
-    if os.path.isfile(datafileroot + "sigfit.txt"):
-        sighistfitname = datafileroot + "sigfit.txt"
-    else:
-        sighistfitname = None
-
-    #  This is currently very broken, so it's disabled
-    # if sighistfitname is not None:
-    #    thepcts = np.array([0.95, 0.99, 0.995, 0.999])
-    #    thervals = tide_stats.rfromp(sighistfitname, thepcts)
-    #    tide_stats.printthresholds(thepcts, thervals, 'Crosscorrelation significance thresholds from data:')
-
-    # set the background image
-    if "anatomic" in overlays:
-        bgmap = "anatomic"
-    else:
-        bgmap = None
-
-    # set up the timecourse plot window
-    print("setting up timecourse plot window")
-    xpos = int(currentdataset.xdim) // 2
-    ypos = int(currentdataset.ydim) // 2
-    zpos = int(currentdataset.zdim) // 2
-    if usecorrout:
-        timeaxis = (
-            np.linspace(
-                0.0,
-                overlays["corrout"].tdim * overlays["corrout"].tr,
-                num=overlays["corrout"].tdim,
-                endpoint=False,
-            )
-            + overlays["corrout"].toffset
+            verbose=verbosity,
         )
-    else:
-        timeaxis = (
-            np.linspace(
-                0.0,
-                overlays[currentdataset.focusmap].tdim * overlays[currentdataset.focusmap].tr,
-                num=overlays[currentdataset.focusmap].tdim,
-                endpoint=False,
+        if len(thesubjects) > 0:
+            # check to see that the dimensions match
+            dimmatch, sizematch, spacematch, affinematch = check_rt_spatialmatch(
+                thissubject, thesubjects[0]
             )
-            + overlays[currentdataset.focusmap].toffset
-        )
-    tpos = 0
-
-    # set position and scale of images
-    print("setting position and scale of images")
-    lg_imgsize = 256.0
-    sm_imgsize = 32.0
-    xfov = currentdataset.xdim * currentdataset.xsize
-    yfov = currentdataset.ydim * currentdataset.ysize
-    zfov = currentdataset.zdim * currentdataset.zsize
-    maxfov = np.max([xfov, yfov, zfov])
-    scalefacx = (lg_imgsize / maxfov) * currentdataset.xsize
-    scalefacy = (lg_imgsize / maxfov) * currentdataset.ysize
-    scalefacz = (lg_imgsize / maxfov) * currentdataset.zsize
-
-    if verbosity > 1:
-        print("setting overlay defaults")
-    for themap in currentdataset.allloadedmaps + currentdataset.loadedfuncmasks:
-        overlays[themap].setLUT(
-            defaultdict[themap]["colormap"], alpha=LUT_alpha, endalpha=LUT_endalpha
-        )
-        overlays[themap].setisdisplayed(defaultdict[themap]["display"])
-        overlays[themap].setLabel(defaultdict[themap]["label"])
-    if verbosity > 1:
-        print("done setting overlay defaults")
-
-    if verbosity > 1:
-        print("setting geometric masks")
-    if "geommask" in overlays:
-        thegeommask = overlays["geommask"].data
-        if verbosity > 1:
-            print("setting geometric mask")
-    else:
-        thegeommask = None
-        if verbosity > 1:
-            print("setting geometric mask to None")
-
-    for theoverlay in currentdataset.loadedfuncmaps:
-        overlays[theoverlay].setGeomMask(thegeommask)
-    if verbosity > 1:
-        print("done setting geometric masks")
-
-    if verbosity > 1:
-        print("setting functional masks")
-        print(currentdataset.loadedfuncmaps)
-    for theoverlay in currentdataset.loadedfuncmaps:
-        if theoverlay != "failimage":
-            if "p_lt_0p050_mask" in overlays and False:  # disable this BBF 2/8/18
-                overlays[theoverlay].setFuncMask(overlays["p_lt_0p050_mask"].data)
-                ui.setMask_Button.setText("p<0.05")
-            else:
-                overlays[theoverlay].setFuncMask(overlays["lagmask"].data)
-                ui.setMask_Button.setText("Valid mask")
-    if verbosity > 1:
-        print("done setting functional masks")
-
-    if "anatomic" in overlays:
-        overlays["anatomic"].setFuncMask(None)
-        overlays["anatomic"].setGeomMask(None)
-
-    if "atlas" in overlays:
-        overlays["atlas"].setGeomMask(thegeommask)
-        overlays["atlas"].setFuncMask(overlays["atlasmask"].data)
-
-    if args.verbose > 0:
-        for theoverlay in overlays:
-            overlays[theoverlay].summarize()
-
-    def loadpane(themap, thepane, view, button, panemap, orthoimages, bgmap=None):
-        if themap.display_state:
-            if bgmap is None:
-                orthoimages[themap.name] = OrthoImageItem(
-                    themap,
-                    view[thepane],
-                    view[thepane],
-                    view[thepane],
-                    button=button[thepane],
-                    imgsize=sm_imgsize,
-                    verbose=verbosity,
-                )
+            if dimmatch or args.ignoredimmatch:
+                thesubjects.append(thissubject)
             else:
-                orthoimages[themap.name] = OrthoImageItem(
-                    themap,
-                    view[thepane],
-                    view[thepane],
-                    view[thepane],
-                    button=button[thepane],
-                    bgmap=bgmap,
-                    imgsize=sm_imgsize,
-                    verbose=verbosity,
-                )
-            panemap[thepane] = themap.name
-
-    if verbosity > 1:
-        print("focusmap is:", currentdataset.focusmap, "bgmap is:", bgmap)
-    if bgmap is None:
-        mainwin = OrthoImageItem(
-            overlays[currentdataset.focusmap],
-            ui.main_graphicsView_ax,
-            ui.main_graphicsView_cor,
-            ui.main_graphicsView_sag,
-            imgsize=lg_imgsize,
-            enableMouse=True,
-            verbose=verbosity,
-        )
-    else:
-        mainwin = OrthoImageItem(
-            overlays[currentdataset.focusmap],
-            ui.main_graphicsView_ax,
-            ui.main_graphicsView_cor,
-            ui.main_graphicsView_sag,
-            bgmap=overlays[bgmap],
-            imgsize=lg_imgsize,
-            enableMouse=True,
-            verbose=verbosity,
-        )
+                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,
+    )
 
-    orthoimages = {}
-    if verbosity > 1:
-        print("loading panes")
-    availablepanes = len(overlayGraphicsViews)
-    numnotloaded = 0
-    numloaded = 0
-    for idx, themap in enumerate(currentdataset.dispmaps):
-        if overlays[themap].display_state:
-            if (numloaded > availablepanes - 1) or (
-                (numloaded > availablepanes - 2) and (themap != "corrout")
-            ):
-                if verbosity > 1:
-                    print("skipping map ", themap, "(", idx, "): out of display panes")
-                numnotloaded += 1
-            else:
-                if verbosity > 1:
-                    print("loading map ", themap, "(", idx, ") into pane ", numloaded)
-                if bgmap is None:
-                    loadpane(
-                        overlays[themap],
-                        numloaded,
-                        overlayGraphicsViews,
-                        overlaybuttons,
-                        panetomap,
-                        orthoimages,
-                    )
-                else:
-                    loadpane(
-                        overlays[themap],
-                        numloaded,
-                        overlayGraphicsViews,
-                        overlaybuttons,
-                        panetomap,
-                        orthoimages,
-                        bgmap=overlays[bgmap],
-                    )
-                numloaded += 1
+    for thebutton in [ui.nextFile_Button]:
+        if len(thesubjects) == 1:
+            thebutton.setDisabled(True)
+            thebutton.hide()
         else:
-            if verbosity > 1:
-                print("not loading map ", themap, "(", idx, "): display_state is False")
-    if verbosity > 1:
-        print("done loading panes")
-    if numnotloaded > 0:
-        print("WARNING:", numnotloaded, "maps could not be loaded - not enough panes")
+            thebutton.clicked.connect(nextFileButtonPressed)
 
     # wire up the display range controls
     ui.resetDispLimits_Button.clicked.connect(resetDispLimits)
@@ -2242,7 +2324,7 @@ 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)