Delete .virtual_documents

.virtual_documents/data/Untitled.ipynb

@@ -1,11 +0,0 @@
-import pandas as pd
-
-# get FCD ids
-df = pd.read_csv("participants.tsv", sep="\t") 
-fcd_ids = df[df['group']=='fcd']['participant_id']
-
-
-
-
-
-

.virtual_documents/data/data_tests.ipynb

@@ -1,255 +0,0 @@
-import pandas as pd
-
-# get FCD ids
-df = pd.read_csv("participants.tsv", sep="\t") 
-fcd_ids = df[df['group']=='fcd']['participant_id']
-
-# get train/test
-train = df[(df['group'] == 'fcd') & (df['split'] == 'train')]
-print(len(train))
-
-# update with new splits
-
-# filter FCD samples
-fcd_df = df[df['group'] == 'fcd'].copy()
-# shuffle indices
-fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)
-# compute split index
-n_train = int(len(fcd_df) * 0.9)
-# assign split labels
-fcd_df.loc[:n_train-1, 'split'] = 'train'
-fcd_df.loc[n_train:, 'split'] = 'val'
-#update
-df.loc[fcd_df.index, 'split'] = fcd_df['split']
-
-
-# new train amount
-train = df[(df['group'] == 'fcd') & (df['split'] == 'train')]
-print(len(train))
-
-
-# get train ids
-train_ids = df[(df['group'] == 'fcd') & (df['split'] == 'train')]['participant_id']
-train_ids.head()
-
-
-val = df[(df['group'] == 'fcd') & (df['split'] == 'val')]
-print(len(val))
-
-
-# get train ids
-val_ids = df[(df['group'] == 'fcd') & (df['split'] == 'val')]['participant_id']
-val_ids.head()
-
-
-from pathlib import Path
-import re
-
-masks = 0
-t1w = 0
-flair = 0
-
-# how many have masks
-for id in fcd_ids:
-    folder   = Path(f"{id}/anat/")
-    pattern  = re.compile(r".*_roi\.nii\.gz$")   # ← regex: any name ending exactly in “_roi.nii.gz”
-    roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())
-    if roi_exists:
-        masks += 1
-
-# how many have t1w
-for id in fcd_ids:
-    folder   = Path(f"{id}/anat/")
-    pattern  = re.compile(r".*_T1w\.nii\.gz$")   # ← regex: any name ending exactly in “_roi.nii.gz”
-    roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())
-    if roi_exists:
-        t1w += 1
-
-# how many have flair
-for id in fcd_ids:
-    folder   = Path(f"{id}/anat/")
-    pattern  = re.compile(r".*_FLAIR\.nii\.gz$")   # ← regex: any name ending exactly in “_roi.nii.gz”
-    roi_exists = any(pattern.fullmatch(p.name) for p in folder.iterdir())
-    if roi_exists:
-        flair += 1
-
-print(masks, t1w, flair)
-
-
-import os, nibabel, torch, numpy as np
-import torch.nn as nn
-from torch.utils.data import Dataset
-import pandas as pd
-import re
-
-
-class InpaintVolumes(Dataset):
-    """
-    Y  : float32  [C, D, H, W]   full multi-modal MRI stack
-    M  : float32  [1, D, H, W]   binary in-painting mask (shared by all mods)
-    Y_void = Y * (1 - M)         context with lesion region blanked
-    name : identifier string
-    """
-
-    # ------------------------------------------------------------
-    def __init__(self,
-                 root_dir: str,
-                 subset: str = 'train',          # 'train' | 'val'
-                 img_size: int = 256,            # 128 or 256 cube
-                 modalities: tuple = ('T1w',),    # order defines channel order
-                 normalize=None):
-        super().__init__()
-        self.root_dir   = os.path.expanduser(root_dir)
-        self.subset     = subset
-        self.img_size   = img_size
-        self.modalities = modalities           
-        self.normalize  = normalize or (lambda x: x)
-        self.cases      = self._index_cases()   # ⇒ list[dict]
-
-    # ------------------------------------------------------------
-    def _index_cases(self):
-        """
-        Build a list like:
-            {'img': {'T1w': path, 'FLAIR': path, ...},
-             'mask': path,
-             'name': case_id}
-        Edit only this block to suit your folder / filename scheme.
-        """
-        cases = []
-        
-        # metadata
-        df = pd.read_csv(f"{self.root_dir}/participants.tsv", sep="\t") 
-        # update with new splits
-        
-        # filter FCD samples
-        fcd_df = df[df['group'] == 'fcd'].copy()
-        # shuffle indices
-        fcd_df = fcd_df.sample(frac=1, random_state=42).reset_index(drop=True)
-        # compute split index
-        n_train = int(len(fcd_df) * 0.9)
-        # assign split labels
-        fcd_df.loc[:n_train-1, 'split'] = 'train'
-        fcd_df.loc[n_train:, 'split'] = 'val'
-        #update
-        df.loc[fcd_df.index, 'split'] = fcd_df['split']
-
-        missing = []
-        
-        for participant_id in df[(df['split']==self.subset) & (df['group']=='fcd')]['participant_id']:
-            case_dir = f"{self.root_dir}/{participant_id}/anat/"
-            files = os.listdir(case_dir)
-            
-            img_dict = {}
-            for mod in self.modalities:
-                pattern = re.compile(rf"^{re.escape(participant_id)}.*{re.escape(mod)}\.nii\.gz$")
-                matches = [f for f in files if pattern.match(f)]
-                assert matches, f"Missing {mod} for {participant_id} in {case_dir}"
-                img_dict[mod] = os.path.join(case_dir, matches[0])
-
-            mask_matches = [f for f in files if re.match(rf"^{re.escape(participant_id)}.*roi\.nii\.gz$", f)]
-            mask_path = os.path.join(case_dir, mask_matches[0])
-
-            cases.append({'img': img_dict, 'mask': mask_path, 'name': participant_id})
-        
-        return cases
-
-    # ------------------------------------------------------------
-    def _pad_to_cube(self, vol, fill=0.0):
-        """Symmetric 3-D pad to [img_size³].  `vol` is [*, D, H, W]."""
-        D, H, W = vol.shape[-3:]
-        pad_D, pad_H, pad_W = self.img_size - D, self.img_size - H, self.img_size - W
-        pad = (pad_W // 2, pad_W - pad_W // 2,
-               pad_H // 2, pad_H - pad_H // 2,
-               pad_D // 2, pad_D - pad_D // 2)
-        return nn.functional.pad(vol, pad, value=fill)
-
-    # ------------------------------------------------------------
-    def __getitem__(self, idx):
-        rec  = self.cases[idx]
-        name = rec['name']
-
-        # ---------- load C modalities --------------------------
-        vols = []
-        for mod in self.modalities:                       
-            mod_path = rec['img'][mod]                    
-            arr = nibabel.load(mod_path).get_fdata().astype(np.float32)
-            
-            # robust min-max clipping and normalization
-            lo, hi = np.quantile(arr, [0.001, 0.999])
-            arr = np.clip(arr, lo, hi)
-            arr = (arr - lo) / (hi - lo + 1e-6)
-        
-            vols.append(torch.from_numpy(arr))
-
-        first_mod = self.modalities[0]
-        nii_obj   = nibabel.load(rec['img'][first_mod])
-        affine    = nii_obj.affine
-        
-        Y = torch.stack(vols, dim=0)            # [C, D, H, W]
-
-        # ---------- load mask ----------------------------------
-        M_arr = nibabel.load(rec['mask']).get_fdata().astype(np.uint8)
-        M = torch.from_numpy(M_arr).unsqueeze(0)      # [1, D, H, W]
-        M = (M > 0).to(Y.dtype)
-
-        # ---------- pad (and optional downsample) --------------
-        Y = self._pad_to_cube(Y, fill=0.0)
-        M = self._pad_to_cube(M, fill=0.0)
-        if self.img_size == 128:
-            pool = nn.AvgPool3d(2, 2)
-            Y = pool(Y);  M = pool(M)
-
-        # ---------- derive context image -----------------------
-        Y_void = Y * (1 - M)
-
-        return Y, M, Y_void, name, affine    # shapes: [C, D, H, W], [1, D, H, W], [C, D, H, W], ...
-
-    # ------------------------------------------------------------
-    def __len__(self):
-        return len(self.cases)
-
-
-# Test cell ───────────────────────────────────────────────────
-from pathlib import Path
-from torch.utils.data import DataLoader
-import numpy as np
-
-root   = Path("")      # ← update
-dl     = InpaintVolumes(
-            root_dir=root,
-            subset='train',
-            img_size=256,
-            modalities=('T1w',))
-
-loader = DataLoader(dl, batch_size=1, shuffle=True, num_workers=0)
-
-print(type(loader))
-
-# grab one sample
-Y, M, Y_void, name, affine = next(iter(loader))
-
-print("case:", name[0])
-print("Y      :", Y.shape, Y.dtype, f"min={Y.min():.3f}", f"max={Y.max():.3f}")
-print("M      :", M.shape, M.dtype, f"mask voxels={M.sum().item()}")
-print("Y_void :", Y_void.shape, Y_void.dtype)
-
-# quick assertions
-C = len(dl.modalities)
-print(Y.shape[1:], M.shape[1:])
-assert Y.shape[1:] == M.shape[1:], "spatial mismatch"
-assert Y.shape[0] == C,           "channel count mismatch"
-assert torch.allclose(Y * (1-M), Y_void), "Y_void incorrect"
-
-print(affine)
-
-print("✅ dataloader sanity-check passed")
-
-
-nibabel.save(nibabel.Nifti1Image(Y[0].numpy(), affine[0]),
-          f"{name[0]}_T1w_proc.nii.gz")
-
-
-
-
-
-