oceanproc 1.1.7__tar.gz → 1.2.0__tar.gz

{oceanproc-1.1.7 → oceanproc-1.2.0}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.1
 Name: oceanproc
-Version: 1.1.7
+Version: 1.2.0
 Summary: MRI preprocessing for WUSTL Ocean labs
 Author-Email: Ramone Agard <rhagard@wustl.edu>, Joey Scanga <joeyscanga92@gmail.com>
 Requires-Python: <3.13,>=3.10
+Requires-Dist: sphinx-rtd-theme<3.0.0,>=2.0.0
 Requires-Dist: flask<4.0.0,>=3.0.3
 Requires-Dist: asttokens<3.0.0,>=2.4.1
 Requires-Dist: numpy>=1.26.0

{oceanproc-1.1.7 → oceanproc-1.2.0}/oceanproc/bids_wrapper.py

@@ -11,7 +11,7 @@ from textwrap import dedent
 import xml.etree.ElementTree as et
 from .utils import exit_program_early, prompt_user_continue, prepare_subprocess_logging, debug_logging, log_linebreak, flags, run_subprocess
 import logging
-from bids import BIDSLayout
+from bids import BIDSLayout, BIDSLayoutIndexer
 from bisect import bisect
 module_logger = logging.getLogger("fsspec")
 module_logger.setLevel(logging.CRITICAL)
@@ -23,7 +23,7 @@ remove_unusable -> relate xml and json with name and aqcuisition time (and serie
 
 
 @debug_logging
-def remove_unusable_runs(bids_path:Path, subject:str, session:str):
+def remove_unusable_runs(bids_layout:BIDSLayout, subject:str, session:str):
     """
     Will remove unusable scans from list of scans after dcm2bids has run.
 
@@ -41,7 +41,6 @@ def remove_unusable_runs(bids_path:Path, subject:str, session:str):
     logger.info("####### Removing the scans marked 'unusable' #######\n")
 
     # Try to delete based on "quality" key in sidecar files:
-    bids_layout = BIDSLayout(bids_path, validate=False)
     data_files = bids_layout.get(subject=subject, session=session, extension="nii.gz", datatype=".*", regex_search=True)
     if len(data_files) == 0:
         exit_program_early("Could not find any data files in the bids directory.")

{oceanproc-1.1.7 → oceanproc-1.2.0}/oceanproc/group_series.py

@@ -8,7 +8,12 @@ from pathlib import Path
 import xml.etree.ElementTree as et
 from bids import BIDSLayout
 import logging
+
+from bids.layout import BIDSFile
 from .utils import exit_program_early, debug_logging, log_linebreak, flags
+import nibabel as nib
+import numpy as np
+import shutil
 
 module_logger = logging.getLogger("fsspec")
 module_logger.setLevel(logging.CRITICAL)
@@ -46,11 +51,33 @@ logger = logging.getLogger(__name__)
 #     return (sorted(localizers), study_id)
 
 DEFAULT_LOCALIZER_LABEL = "00"
+EXTRACTED_ACQ_VALUE = "bestVol"
 
 def get_empty_group():
     return {"task":set(), "fmapAP": set(), "fmapPA": set()}
 
 
+def get_json_sidecar(bids_file:BIDSFile|str, bids_layout:BIDSLayout) -> BIDSFile:
+    if isinstance(bids_file, BIDSFile):
+        bids_file = bids_file.path
+    sidecar_ents = bids_layout.parse_file_entities(bids_file) | {"extension":".json"}
+    if "fmap" in sidecar_ents:
+        del sidecar_ents["fmap"]
+    sidecar_files = bids_layout.get(**sidecar_ents)
+    valid_files = [bf for bf in sidecar_files if set(sidecar_ents.keys()) == set(bids_layout.parse_file_entities(bf).keys())]
+    if len(valid_files) != 1:
+        exit_program_early(f"Cannot find the associated JSON file for bids file: {bids_file}")
+    return valid_files[0]
+
+
+def reset_intended_for(fmap_file:BIDSFile|str, bids_layout:BIDSLayout):
+    sidecar_file = get_json_sidecar(fmap_file, bids_layout)
+    jd = sidecar_file.get_dict()
+    jd["IntendedFor"] = []
+    with open(sidecar_file.path, "w") as out_file:
+        json.dump(jd, out_file, indent=4)
+
+
 def get_func_from_bids(bids_layout: BIDSLayout,
                        subject:str,
                        session:str,
@@ -78,6 +105,11 @@ def get_fmap_from_bids(bids_layout: BIDSLayout,
         exit_program_early("Could not find any fieldmap files for this subject and session.")
 
     for epi_file in fmap_files:
+        reset_intended_for(epi_file, bids_layout)
+        file_entities = bids_layout.parse_file_entities(epi_file.path)
+        # skip previously extracted acqusitions
+        if ("acquisition" in file_entities) and file_entities["acquisition"] == EXTRACTED_ACQ_VALUE:
+            continue
         acq_time = datetime.strptime(epi_file.entities["AcquisitionTime"], "%H:%M:%S.%f")
         direction = f"fmap{epi_file.entities['direction']}"
         localizer_block_label = epi_file.entities["localizer_block"] if "localizer_block" in epi_file.entities else DEFAULT_LOCALIZER_LABEL
@@ -154,12 +186,12 @@ def even_fmap_pairing(localizer_group: dict) -> tuple:
 @debug_logging
 def map_fmap_to_func(subject:str,
                      session:str,
-                     bids_path:Path,
-                     allow_uneven_fmap_groups: bool = False):
+                     layout:BIDSLayout,
+                     allow_uneven_fmap_groups: bool = False,
+                     extract_best_fmap: bool = False):
     
     logger.info("####### Pairing field maps to functional runs #######\n")
 
-    layout = BIDSLayout(bids_path, validate=False)
     groups = dict()
     get_func_from_bids(bids_layout=layout,
                        subject=subject,
@@ -183,7 +215,7 @@ def map_fmap_to_func(subject:str,
             if not allow_uneven_fmap_groups:
                 exit_program_early(f"--allow_uneven_fmap_groups not set. (#AP: {len(group['fmapAP'])}, #PA: {len(group['fmapPA'])})")
             elif len(group["fmapPA"]) == 0 or len(group["fmapAP"]) == 0:
-                exit_program_early(f"Not enough fieldmaps in one direction (#AP: {len(group['fmapAP'])}, #PA: {len(group['fmapPA'])})")
+                exit_program_early(f"Not enough fieldmaps in one direction (AP:\n{group['fmapAP']}, {len(group['fmapAP'])=}\nPA:\n{group['fmapAP']}, {len(group['fmapPA'])=})")
             fmap_pairs = uneven_fmap_pairing(group)
         else:
             fmap_pairs = even_fmap_pairing(group)
@@ -195,27 +227,36 @@ def map_fmap_to_func(subject:str,
             fmap_times.append(times[0] + (abs(times[1] - times[0]) / 2))
 
         # pair task runs with field maps based on closest Acquisition Time
-        map_pairings = {s:[] for s in fmap_pairs}
+        time_pairings = {s:[] for s in fmap_pairs}
         for (t_file, t_acq_time) in group["task"]:
             diff = list(map(lambda x: abs(x - t_acq_time), fmap_times))
             pairing = fmap_pairs[diff.index(min(diff))]
-            map_pairings[pairing].append(t_file)
+            time_pairings[pairing].append(t_file)
+        
+        # gather the sidecar files and extract volumes if requested
+        file_pairing = dict()
+        for (ap_tup, pa_tup), task_files in time_pairings.items():
+            if extract_best_fmap:
+                ap_info = extract_best_acqusition(ap_tup[0], layout)
+                pa_info = extract_best_acqusition(pa_tup[0], layout)
+            else:
+                ap_info = (ap_tup[0], get_json_sidecar(ap_tup[0], layout))
+                pa_info = (pa_tup[0], get_json_sidecar(pa_tup[0], layout))
+            file_pairing[(ap_info, pa_info)] = task_files
 
         # add the list of task run files that are paired with each field map in their json files
         pairing_strs = []
-        for (ap_tup, pa_tup), task_files in map_pairings.items():
-            for fmap_file, fmap_type in ((ap_tup[0], "ap"), (pa_tup[0], "pa")):
-                fmap_json = [f for f in fmap_file.get_associations() if f.entities['extension'] == ".json"]
-                if len(fmap_json) != 1:
-                    exit_program_early(f"Cannot find the associated JSON file for fmap: {fmap_file.filename}")
-                fmap_json = fmap_json[0]
+        for fmap_info, task_files in file_pairing.items():
+            for fmap_file, fmap_json in fmap_info:
                 intended_for = [tf.relpath.split("/", 1)[-1] for tf in task_files]
                 task_series = set([f"{tf.filename}({str(tf.entities['SeriesNumber'])})" for tf in task_files])
-                jd = fmap_json.get_dict()
+                jd = None
+                with open(fmap_json.path, "r") as fjson:
+                    jd = json.load(fjson)
                 jd["IntendedFor"] = intended_for
                 with open(fmap_json.path, "w") as out_file:
                     logger.debug(f"writing field map pairing information to file: {fmap_json.filename}")
-                    out_file.write(json.dumps(jd, indent=4))
+                    json.dump(jd, out_file, indent=4)
                 pairing_strs.append((f"{fmap_file.filename}:{jd['SeriesNumber']}", ' '.join(task_series)))
 
         # report the fieldmap pairings
@@ -253,6 +294,47 @@ def map_fmap_to_func_with_pairing_file(bids_dir_path: Path,
                 json.dump(fmap_dict, f, indent=4)
 
 
+def extract_best_acqusition(fmap_file: str|BIDSFile, bids_layout: BIDSLayout) -> tuple[BIDSFile]:
+
+    if isinstance(fmap_file, BIDSFile):
+        fmap_file = fmap_file.path
+
+    fmap_img = nib.load(fmap_file)
+    fmap_data = fmap_img.get_fdata()
+    assert len(fmap_data.shape) == 4, f"Fieldmap supplied does not have 4 dimensions : {fmap_file}"
+
+    # file the volume with the lowest standard deviation
+    slice_diffs = np.diff(fmap_data, axis=2)
+    vol_stds = np.nanstd(slice_diffs, axis=(0,1,2))
+    best_vol = np.argmin(vol_stds)
+
+    # create a new bids name for the best volume
+    new_entities = bids_layout.parse_file_entities(fmap_file) | {"acquisition" : EXTRACTED_ACQ_VALUE}
+    best_acq_fmap = bids_layout.build_path(new_entities)
+    # save out the new image
+    best_acq_fmap_img = fmap_img.__class__(fmap_data[:,:,:,best_vol], affine=fmap_img.affine)
+    logger.info(f"saving extracted fieldmap to path: {best_acq_fmap}")
+    nib.save(best_acq_fmap_img, best_acq_fmap)
+
+    # create a new bids name for the sidecar file
+    sidecar_entities = new_entities | {"extension": ".json"}
+    best_acq_json = bids_layout.build_path(sidecar_entities)
+    # find the original sidecar file and copy it
+    fmap_json = get_json_sidecar(fmap_file, bids_layout)
+    jd = {}
+    with open(fmap_json.path, "r") as fjs:
+        jd = json.load(fjs)
+
+    # add metadata and save
+    jd["Sources"] = ["bids::"+str(Path(fmap_json.path).relative_to(bids_layout.root))]
+    jd["ExtractedVolume"] = int(best_vol + 1)
+    with open(best_acq_json, "w") as out_js:
+        json.dump(jd, out_js, indent=4)
+
+    return (BIDSFile(best_acq_fmap), BIDSFile(best_acq_json))
+    
+
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
         prog="group_series.py",

{oceanproc-1.1.7 → oceanproc-1.2.0}/oceanproc/ocean_proc.py

@@ -5,13 +5,14 @@ import sys
 from pathlib import Path
 import logging
 import datetime
-from .bids_wrapper import dicom_to_bids, remove_unusable_runs, extend_session
-from .group_series import map_fmap_to_func, map_fmap_to_func_with_pairing_file
-from .preprocessing_wrapper import process_data, adult_defaults, infant_defaults, mount_opts
-from .segmentation_wrapper import segmentation_args, segment_anatomical
-from .events_long import create_events_and_confounds
-from .utils import exit_program_early, prompt_user_continue, default_log_format, add_file_handler, export_args_to_file, flags, debug_logging, log_linebreak, extract_options, make_option
-from .oceanparse import OceanParser
+from oceanproc.bids_wrapper import dicom_to_bids, remove_unusable_runs, extend_session
+from oceanproc.group_series import map_fmap_to_func, map_fmap_to_func_with_pairing_file
+from oceanproc.preprocessing_wrapper import process_data, adult_defaults, infant_defaults, mount_opts, insert_dummy_frames
+from oceanproc.segmentation_wrapper import segmentation_args, segment_anatomical
+from oceanproc.events_long import create_events_and_confounds
+from oceanproc.utils import exit_program_early, prompt_user_continue, default_log_format, add_file_handler, export_args_to_file, flags, debug_logging, log_linebreak, extract_options, make_option
+from oceanproc.oceanparse import OceanParser
+from bids import BIDSLayout, BIDSLayoutIndexer
 import shutil
 from textwrap import dedent
 
@@ -40,6 +41,31 @@ def make_work_directory(dir_path:Path, subject:str, session:str) -> Path:
 
 
 def main():
+
+    def ExistingPath(path):
+        p = Path(path)
+        if not p.exists():
+            raise argparse.ArgumentTypeError(
+                f"path string <{path}> does not represent an existing path"
+            )
+        return p.resolve()
+
+    def ExistingDir(path):
+        p = ExistingPath(path)
+        if not p.is_dir():
+            raise argparse.ArgumentTypeError(
+                f"path string <{path}> does not represent an existing directory"
+            )
+        return p
+
+    def ExistingFile(path):
+        p = ExistingPath(path)
+        if not p.is_file():
+            raise argparse.ArgumentTypeError(
+                f"path string <{path}> does not represent an existing file"
+            )
+        return p
+    
     parser = OceanParser(
         prog="oceanproc",
         description="Ocean Labs adult MRI preprocessing",
@@ -48,7 +74,7 @@ def main():
         epilog="An arguments file can be accepted with @FILEPATH.\nAny additional arguments not listed in the help message will be passed to the preprocessing subprocess.",
         allow_abbrev=False
     )
-    parser.add_argument("--version", action="version", version='%(prog)s v1.1.2')
+    parser.add_argument("--version", action="version", version='%(prog)s v1.1.8')
     session_args = parser.add_argument_group("Session Specific")
     config_args = parser.add_argument_group("Configuration Arguments", "These arguments are saved to a file if the '--export_args' option is used")
     parser.register("type", "Full-Path", lambda p: Path(p).resolve())
@@ -57,13 +83,13 @@ def main():
                               help="The identifier of the subject to preprocess")
     session_args.add_argument("--session", "-se", required=True,
                               help="The identifier of the session to preprocess")
-    session_args.add_argument("--source_data", "-sd", type=Path,
+    session_args.add_argument("--source_data", "-sd", type=ExistingDir,
                               help="The path to the directory containing the raw DICOM files for this subject and session")
     session_args.add_argument("--skip_dcm2bids", action="store_true",
                               help="Flag to indicate that dcm2bids does not need to be run for this subject and session")
-    session_args.add_argument("--usability_file", "-u", type=Path,
+    session_args.add_argument("--usability_file", "-u", type=ExistingFile,
                               help="The path to the usability file for this subject and session; this file can be either be an xml or json file. All runs will be used if no file is provided.")
-    session_args.add_argument("--longitudinal", "-lg", type=Path, nargs="+", action="append",
+    session_args.add_argument("--longitudinal", "-lg", type=ExistingPath, nargs="+", action="append",
                               help="Addtional sourcedata and usability pair to include with this BIDs subject and session")
     session_args.add_argument("--skip_fmap_pairing", action="store_true",
                               help="Flag to indicate that the pairing of fieldmaps to BOLD runs does not need to be performed for this subject and session")
@@ -79,19 +105,19 @@ def main():
                               help="Flag to stop the deletion of the fMRIPrep working directory")
     session_args.add_argument("--debug_mode", action="store_true",
                               help="Flag to run the program in debug mode for more verbose logging")
-    session_args.add_argument("--fmap_pairing_file", type=Path,
+    session_args.add_argument("--fmap_pairing_file", type=ExistingFile,
                               help="Path to JSON containing info on how to pair fieldmaps to BOLD runs.")
 
-    config_args.add_argument("--bids_path", "-b", type=Path, required=True,
+    config_args.add_argument("--bids_path", "-b", type=ExistingDir, required=True,
                              help="The path to the directory containing the raw nifti data for all subjects, in BIDS format")
-    config_args.add_argument("--derivs_path", "-d", type=Path, required=True,
+    config_args.add_argument("--derivs_path", "-d", type=ExistingDir, required=True,
                              help="The path to the BIDS formated derivatives directory for this subject")
     config_args.add_argument("--derivs_subfolder", "-ds", default=None,
                              help=f"""The subfolder in the derivatives directory where bids style outputs should be stored. 
                                   The default is {adult_defaults.derivs_subfolder} or {infant_defaults.derivs_subfolder} if the '--infant' flag is set.""")
-    config_args.add_argument("--bids_config", "-c", type=Path, required=True,
+    config_args.add_argument("--bids_config", "-c", type=ExistingFile, required=True,
                              help="The path to the dcm2bids config file to use for this subject and session")
-    config_args.add_argument("--nordic_config", "-n", type=Path,
+    config_args.add_argument("--nordic_config", "-n", type=ExistingFile,
                              help="The path to the second dcm2bids config file to use for this subject and session. This implies that the session contains NORDIC data")
     config_args.add_argument("--nifti", action=argparse.BooleanOptionalAction,
                              help="Flag to specify that the source directory contains files of type NIFTI (.nii/.jsons) instead of DICOM")
@@ -101,36 +127,43 @@ def main():
                              help="framewise displacement threshold (in mm) to determine outlier framee (Default is 0.9).")
     config_args.add_argument("--skip_bids_validation", action=argparse.BooleanOptionalAction,
                              help="Specifies skipping BIDS validation (only enabled for fMRIprep step)")
-    config_args.add_argument("--fs_subjects_dir", "-fs", type=Path,
+    config_args.add_argument("--fs_subjects_dir", "-fs", type=ExistingDir,
                              help="The path to the directory that contains previous FreeSurfer outputs/derivatives to use for fMRIPrep. If empty, this is the path where new FreeSurfer outputs will be stored.")
     config_args.add_argument("--allow_uneven_fmap_groups", action="store_true",
                              help="Flag to allow for automated fieldmap pairing when there's more AP- than PA-encoded fieldmaps, or vice versa (will still error out if at least one of each is not present.)")
+    config_args.add_argument("--extract_best_fmap", action="store_true",
+                             help="Flag to specify that the lowest variance fieldmap volume should be extracted from each fieldmap, and used for distortion correction (opposed to all volumes being used)")
+    config_args.add_argument("--dscans_path", type=ExistingDir,
+                             help="""The path to the directory containing 'dscans' files for inserting dummy scans into bold runs. Must be named exactly as corresponding bold image except with 'dscans' as 
+                             the suffix and '.tsv' as the extension. Contents of the file must be a column, titled 'dummy_scan', with ones and zeros. Ones denote which frames should be dummy scans.""")
     config_args.add_argument("--precomputed_derivatives", "-pd", type="Full-Path", dest="derivatives", nargs="*",
                              help="A list of paths to any BIDS-style precomputed derivatives that should be used in preprocessing. (Ex. /path/to/bibsnet)")
-    config_args.add_argument("--work_dir", "-w", type=Path, required=True,
+    config_args.add_argument("--work_dir", "-w", type=ExistingDir, required=True,
                              help="The path to the working directory used to store intermediate files")
-    config_args.add_argument("--fs_license", "-l", type=Path, required=True,
+    config_args.add_argument("--fs_license", "-l", type=ExistingFile, required=True,
                              help="The path to the license file for the local installation of FreeSurfer")
     config_args.add_argument("--image_version", "-iv", default=None,
                              help=f"""The version of fmriprep to use; It is reccomended that an entire study use the same version. 
                                   The default is {adult_defaults.image_version} or {infant_defaults.image_version} if the '--infant' flag is set.""")
     config_args.add_argument("--infant", "-I", action=argparse.BooleanOptionalAction,
                              help="Flag to specify that NiBabies should be used instead of fMRIPrep")
-    config_args.add_argument("--bibsnet_image_path", "-bi", type=Path,
+    config_args.add_argument("--preproc_image_path", "-pi", type=ExistingFile,
+                             help="Path to a fMRIPrep or NiBabies apptainer image to use for preprocessing. If provided, this apptainer image will be used instead of docker. (NiBabies images should still be used with the '--infant' flag)")
+    config_args.add_argument("--bibsnet_image_path", "-bi", type=ExistingFile,
                              help="Path to the BIBSnet apptainer image to use for segmentation. If provided, BIBSnet segmentation will be run and the outputs will be used for preprocessing. (Must be used with the '--infant' flag)")
-    config_args.add_argument("--bibsnet_work", "-bw", type=Path,
+    config_args.add_argument("--bibsnet_work", "-bw", type=ExistingDir,
                              help="The path to the working directory used to store intermediate files for BIBSnet")
     args, unknown_args = parser.parse_known_args()
 
-    try:
-        assert args.derivs_path.is_dir(), "Derivatives directory must exist but it cannot be found"
-        assert args.bids_path.is_dir(), "Raw Bids directory must exist but it cannot be found"
-        if not args.skip_dcm2bids:
-            assert args.source_data.is_dir(), "Source data directory must exist but it cannot be found"
-        assert args.work_dir.is_dir(), "Work directroy must exist but it cannot be found"
-    except AssertionError as e:
-        logger.exception(e)
-        parser.error(e)
+    # try:
+    #     assert args.derivs_path.is_dir(), "Derivatives directory must exist but it cannot be found"
+    #     assert args.bids_path.is_dir(), "Raw Bids directory must exist but it cannot be found"
+    #     if not args.skip_dcm2bids:
+    #         assert args.source_data.is_dir(), "Source data directory must exist but it cannot be found"
+    #     assert args.work_dir.is_dir(), "Work directroy must exist but it cannot be found"
+    # except AssertionError as e:
+    #     logger.exception(e)
+    #     parser.error(e)
 
     defaults = infant_defaults if args.infant else adult_defaults
     for k,v in defaults.__dict__.items():
@@ -146,8 +179,8 @@ def main():
         elif bibsnet_path not in args.derivatives:
             args.derivatives.append(bibsnet_path)
 
-    if args.bibsnet_work and (not args.bibsnet_work.exists()):
-        parser.error("BIBSnet working directory must exist but it cannot be found")
+    # if args.bibsnet_work and (not args.bibsnet_work.exists()):
+    #     parser.error("BIBSnet working directory must exist but it cannot be found")
 
     if args.longitudinal:
         for lg_group in args.longitudinal:
@@ -162,6 +195,12 @@ def main():
                 parser.error(f"longitudinal argument cannot have more than 2 elements: {lg_group}")
 
     preproc_image = f"{defaults.image_name}:{args.image_version}"
+    if args.preproc_image_path:
+        # if not args.preproc_image_path.exists():
+        #     parser.error(f"Cannot find the preprocessing apptainer image at the path: {args.preproc_image_path}")
+        flags.apptainer = True
+        preproc_image = args.preproc_image_path
+
     preproc_derivs_path = args.derivs_path / args.derivs_subfolder
 
     log_dir = preproc_derivs_path / f"sub-{args.subject}/log"
@@ -180,7 +219,7 @@ def main():
         try:
             assert args.export_args.parent.exists() and args.export_args.suffix, "Argument export path must be a file path in a directory that exists"
             logger.info(f"####### Exporting Configuration Arguments to: '{args.export_args}' #######")
-            export_args_to_file(args, config_arguments, args.export_args, extra_args=unknown_args)
+            export_args_to_file(args, config_args, args.export_args, extra_args=unknown_args)
         except Exception as e:
             logger.exception(e)
             exit_program_early(e)
@@ -226,10 +265,18 @@ def main():
                                session=args.session,
                                tmp_dir=bids_path,
                                bids_dir=args.bids_path)
+                
+    # create a bids layout object
+    ignore_list = ["tmp_dcm2bids"]
+    if (bids_path / ".bidsignore").is_file():
+        with open(bids_path / ".bidsignore", "r") as f:
+            ignore_list.extend(f.readlines())
+    ignore_list = list(set(ignore_list))
+    bids_layout = BIDSLayout(args.bids_path, validate=False, indexer=BIDSLayoutIndexer(ignore=ignore_list, validate=False))
 
     ##### Remove the scans marked as 'unusable' #####
     remove_unusable_runs(
-        bids_path=args.bids_path,
+        bids_layout=bids_layout,
         subject=args.subject,
         session=args.session
     )
@@ -243,12 +290,15 @@ def main():
                 args.fmap_pairing_file
             )
         else:
+            # update the bids layout
+            bids_layout = BIDSLayout(args.bids_path, validate=False, indexer=BIDSLayoutIndexer(ignore=ignore_list, validate=False))
             map_fmap_to_func(
                 subject=args.subject,
                 session=args.session,
-                bids_path=args.bids_path,
+                layout=bids_layout,
                 # xml_path=xml_data_path,
-                allow_uneven_fmap_groups=args.allow_uneven_fmap_groups
+                allow_uneven_fmap_groups=args.allow_uneven_fmap_groups,
+                extract_best_fmap=args.extract_best_fmap
             )
 
     ##### Run BIBSnet #####
@@ -272,6 +322,17 @@ def main():
         if not bibsnet_path.exists():
             exit_program_early(f"Cannot find the outputs for BIBSnet at the path {bibsnet_path}")
 
+
+    ##### Insert dummy scans in requested #####
+    if args.dscans_path:
+        insert_dummy_frames(
+            subject=args.subject,
+            session=args.session,
+            dscan_dir=args.dscans_path,
+            bids_layout=bids_layout
+        )
+
+
     ##### Run fMRIPrep or NiBabies #####
     all_opts = dict(args._get_kwargs())
 

{oceanproc-1.1.7 → oceanproc-1.2.0}/oceanproc/preprocessing_wrapper.py

@@ -2,6 +2,7 @@
 
 from pathlib import Path
 import logging
+from bids import BIDSLayout
 from .utils import exit_program_early, make_option, prepare_subprocess_logging, flags, debug_logging, log_linebreak, run_subprocess
 import shutil
 from subprocess import Popen, PIPE
@@ -9,6 +10,7 @@ from matplotlib import pyplot as plt
 from bs4 import BeautifulSoup as bsoup
 import pandas as pd
 import numpy as np
+import nibabel as nib
 import json
 import os
 import copy
@@ -29,14 +31,6 @@ infant_defaults = SimpleNamespace(
     derivs_subfolder="nibabies",
 )
 
-# Good arguments to have if not specified
-# { key : (val, can_have_multiple_values)}
-preproc_kwargs = {
-    "cifti-output":("91k", False),
-    "output-spaces": ("fsLR", True),
-    "output-spaces": ("MNI152NLin2009cAsym", True)
-}
-
 # Preprocessing arguments that need to have their paths binded when running docker
 mount_opts = {"fs_subjects_dir",
                   "derivatives"}
@@ -83,6 +77,15 @@ def run_preprocessing(subject:str,
     elif not derivs_path.exists():
         exit_program_early(f"Derivatives path {derivs_path} does not exist.")
     
+    if flags.apptainer:
+        cmd_prelude = "apptainer run --nv --cleanenv --no-mount cwd"
+        mount_flag = "-B"
+    else:
+        uid = Popen(["id", "-u"], stdout=PIPE).stdout.read().decode("utf-8").strip()
+        gid = Popen(["id", "-g"], stdout=PIPE).stdout.read().decode("utf-8").strip()
+        cmd_prelude = f"docker run --rm -i -u {uid}:{gid}"
+        mount_flag = "-v"
+
     additional_mount_paths = []
     additional_mount_args = []
     mount_dex = 1
@@ -90,29 +93,26 @@ def run_preprocessing(subject:str,
         arg_vals = [k]
         if isinstance(v, list):
             for sub_v in v:
-                additional_mount_paths.append(f"-v {sub_v.resolve()}:/deriv{mount_dex}")
+                additional_mount_paths.append(f"{mount_flag} {sub_v.resolve()}:/deriv{mount_dex}")
                 arg_vals.append(f"/deriv{mount_dex}")
                 mount_dex += 1
         else:
-            additional_mount_paths.append(f"-v {v.resolve()}:/deriv{mount_dex}")
+            additional_mount_paths.append(f"{mount_flag} {v.resolve()}:/deriv{mount_dex}")
             arg_vals.append(f"/deriv{mount_dex}")
             mount_dex += 1
         additional_mount_args.append(" ".join(arg_vals))
     additional_mount_paths = " ".join(additional_mount_paths)
     additional_mount_args = " ".join(additional_mount_args)
 
-    uid = Popen(["id", "-u"], stdout=PIPE).stdout.read().decode("utf-8").strip()
-    gid = Popen(["id", "-g"], stdout=PIPE).stdout.read().decode("utf-8").strip()
-
     license_mount = "/opt/freesurfer/license.txt"
     bids_mount = "/data"
     derivs_mount = "/out"
     work_mount = "/work"
-    preproc_command = f"""docker run --rm -i -u {uid}:{gid}
-                            -v {license_file.resolve()}:{license_mount}:ro
-                            -v {bids_path.resolve()}:{bids_mount}:ro
-                            -v {derivs_path.resolve()}:{derivs_mount}
-                            -v {work_path.resolve()}:{work_mount}
+    preproc_command = f"""{cmd_prelude}
+                            {mount_flag} {license_file.resolve()}:{license_mount}:ro
+                            {mount_flag} {bids_path.resolve()}:{bids_mount}:ro
+                            {mount_flag} {derivs_path.resolve()}:{derivs_mount}
+                            {mount_flag} {work_path.resolve()}:{work_mount}
                             {additional_mount_paths}
                             {image_name} {bids_mount} {derivs_mount} participant
                             --participant-label {subject} 
@@ -240,6 +240,74 @@ def add_fd_plot_to_report(subject:str,
         f.write(soup.prettify())
 
 
+def insert_dummy_frames(subject:str,
+                        session:str,
+                        dscan_dir:Path,
+                        bids_layout:BIDSLayout):
+    
+    dscans_suffix = "dscans"
+    dscans_path_pattern = "sub-{subject}[/ses-{session}]/{datatype<func|meg|beh>|func}/sub-{subject}[_ses-{session}]_task-{task}[_acq-{acquisition}][_rec-{reconstruction}][_run-{run}][_echo-{echo}][_recording-{recording}]_{suffix<"+dscans_suffix+">}{extension<.tsv|.json>|.tsv}"
+
+    log_linebreak()
+    logger.info(f"####### Inserting Dummy Scans #######\n")
+
+    # find all bold files
+    func_files = bids_layout.get(subject=subject, session=session, suffix="bold", datatype="func", extension="nii.gz")
+    for bfile in func_files:
+        if not Path(bfile.path).exists:
+            continue
+        # Find the dscans file for bold run
+        dscans_entities = bids_layout.parse_file_entities(bfile.path) | {"suffix":dscans_suffix, "extension":".tsv"}
+        dscans_bids_path = bids_layout.build_path(dscans_entities, path_patterns=[dscans_path_pattern], validate=False)
+        dscans_file = sorted(dscan_dir.glob(Path(dscans_bids_path).name))
+        if len(dscans_file) > 1:
+            exit_program_early(f"Found more than one dscans file for bold run {bfile} --> {dscans_file}")
+        elif len(dscans_file) == 0:
+            logger.info(f"Did not find any dscans files for bold run: {bfile}, file will remain unmodified.")
+            continue
+        dscans_file = dscans_file[0]
+        logger.info(f"found dscans file <{dscans_file.name}> for bold run <{bfile.filename}>")
+
+        dscans_list = pd.read_csv(dscans_file, sep="\t").loc[:, "dummy_scan"].to_numpy().astype(np.int32)
+        bold_img = nib.load(bfile.path)
+        num_bold_frames = bold_img.shape[3]
+        num_dummy_scans = np.sum(dscans_list > 0)
+        num_non_dummy = np.sum(dscans_list == 0)
+
+        # validate length
+        if len(dscans_list) == num_bold_frames:
+            logger.info(f"  dsans file and bold image have the same length. Dummy scans may have already been inserted or length of dscans file is incorrect. Bold file will remain unmodified.")
+            continue
+        elif num_bold_frames != num_non_dummy:
+            exit_program_early(f"Number of non-dummy scans and length of bold data do not match. # non-dummy scans: {num_non_dummy}, # bold frames: {num_bold_frames}")
+
+        logger.info(f"  inserting {num_dummy_scans} dummy scans into the bold run")
+        # create a new bold series with dummy scans inserted
+        bold_data = bold_img.get_fdata()
+        frame_list = []
+        dscans_index = 0
+        for f in range(num_bold_frames):
+            copy_dex = f-1 if f > 0 else f
+            while dscans_list[dscans_index] != 0:
+                frame_list.append(bold_data[:,:,:,copy_dex])
+                dscans_index += 1
+            frame_list.append(bold_data[:,:,:,f])
+            dscans_index += 1
+            # check if end of run needs to be extended
+            if (f == num_bold_frames-1) and (dscans_index < len(dscans_list)):
+                while dscans_index < len(dscans_list):
+                    frame_list.append(bold_data[:,:,:,f])
+                    dscans_index += 1
+
+        if len(frame_list) != len(dscans_list):
+            exit_program_early(f"Something went wrong when creating dummy scans, lengths do not match. bold frames: {len(frame_list)}, dscan length: {len(dscans_list)}")
+        
+        # save new image
+        extended_bold_data = np.stack(frame_list, axis=3)
+        extended_bold_img = bold_img.__class__(extended_bold_data, header=bold_img.header, affine=bold_img.affine)
+        logger.info(f"  saving extended bold image")
+        nib.save(extended_bold_img, bfile.path)
+    
 
 @debug_logging
 def process_data(subject:str,
@@ -273,20 +341,6 @@ def process_data(subject:str,
     :type remove_work_folder: str
     :param **kwargs: any arguments to be passed to the preprocessing subprocess
     """
-
-    # Add in some recommended options
-    for key, (val, multi) in preproc_kwargs.items():
-        if (key in kwargs) and multi:
-            if isinstance(kwargs[key], list):
-                if val not in kwargs[key]:
-                    kwargs[key].append(val)
-            else:
-                if val != kwargs[key]:
-                    kwargs[key] = [kwargs[key], val]
-        elif key not in kwargs:
-            kwargs[key] = val
-
-
     option_chain = " ".join([make_option(v, key=k, delimeter=" ", convert_underscore=True) for k,v in kwargs.items()])
     preproc_title = "NiBabies" if flags.infant else "fMRIPrep"
 

{oceanproc-1.1.7 → oceanproc-1.2.0}/oceanproc/utils.py

@@ -16,7 +16,7 @@ logger = logging.getLogger(__name__)
 
 default_log_format = "%(levelname)s:%(asctime)s:%(module)s: %(message)s"
 
-flags = SimpleNamespace(debug=False, longitudinal=False, infant=False)
+flags = SimpleNamespace(debug=False, longitudinal=False, infant=False, apptainer=False)
 
 bids_entities = ["sub", "ses", "sample", "task", "tracksys",
                  "acq", "ce", "trc", "stain", "rec", "dir",

{oceanproc-1.1.7 → oceanproc-1.2.0}/pyproject.toml

@@ -22,6 +22,7 @@ authors = [
 ]
 requires-python = "<3.13,>=3.10"
 dependencies = [
+    "sphinx-rtd-theme>=2.0.0,<3.0.0",
     "flask<4.0.0,>=3.0.3",
     "asttokens<3.0.0,>=2.4.1",
     "numpy>=1.26.0",
@@ -33,13 +34,13 @@ dependencies = [
     "pybids>=0.16.3",
 ]
 name = "oceanproc"
-version = "1.1.7"
+version = "1.2.0"
 description = "MRI preprocessing for WUSTL Ocean labs"
 readme = "README.md"
 
 [project.scripts]
 oceanproc = "oceanproc.ocean_proc:main"
-oceanfla = "oceanproc.firstlevel.run_glm:main"
+oceanfla_legacy = "oceanproc.firstlevel.run_glm:main"
 
 [dependency-groups]
 dev = [
@@ -47,5 +48,4 @@ dev = [
     "sphinx<8.0.0,>=7.3.7",
     "twine<6.0.0,>=5.1.0",
     "ipython<9.0.0,>=8.29.0",
-    "sphinx-rtd-theme>=2.0.0,<3.0.0",
 ]

oceanproc-1.1.7/oceanproc/firstlevel/Ocean-Proc.code-workspace

@@ -1,8 +0,0 @@
-{
-	"folders": [
-		{
-			"path": "../.."
-		}
-	],
-	"settings": {}
-}