Calcium Imaging Pipeline¶

@schema
class Mouse(dj.Manual):
    definition = """
    mouse_id : int32
    ---
    dob : date
    sex : enum('M', 'F', 'unknown')
    """


@schema
class Session(dj.Manual):
    definition = """
    -> Mouse
    session_date : date
    ---
    experimenter : varchar(100)
    """


@schema
class Scan(dj.Manual):
    definition = """
    -> Session
    scan_idx : int16
    ---
    depth : float32           # imaging depth (um)
    wavelength : float32      # laser wavelength (nm)
    laser_power : float32     # laser power (mW)
    fps : float32             # frames per second
    file_name : varchar(128)  # TIFF filename
    """

@schema
class AverageFrame(dj.Imported):
    definition = """
    -> Scan
    ---
    average_frame : <blob>    # mean fluorescence across frames
    """

    def make(self, key):
        # Get filename from Scan table
        file_name = (Scan & key).fetch1('file_name')
        file_path = DATA_DIR / file_name
        
        # Load TIFF and compute average
        movie = io.imread(file_path)
        avg_frame = movie.mean(axis=0)
        
        # Insert result
        self.insert1({**key, 'average_frame': avg_frame})
        print(f"Processed {file_name}: {movie.shape[0]} frames")

@schema
class Segmentation(dj.Computed):
    definition = """
    -> AverageFrame
    -> SegmentationParam
    ---
    num_rois : int16          # number of detected ROIs
    segmented_mask : <blob>   # labeled mask image
    """

    class Roi(dj.Part):
        definition = """
        -> master
        roi_idx : int16
        ---
        mask : <blob>         # binary mask for this ROI
        center_x : float32    # ROI center x coordinate
        center_y : float32    # ROI center y coordinate
        """

    def make(self, key):
        # Fetch inputs
        avg_frame = (AverageFrame & key).fetch1('average_frame')
        threshold, min_size = (SegmentationParam & key).fetch1('threshold', 'min_size')
        
        # Threshold to get binary mask
        binary_mask = avg_frame > threshold
        
        # Label connected components
        labeled, num_labels = ndimage.label(binary_mask)
        
        # Filter by size and extract ROIs
        roi_masks = []
        for i in range(1, num_labels + 1):  # 0 is background
            roi_mask = (labeled == i)
            if roi_mask.sum() >= min_size:
                roi_masks.append(roi_mask)
        
        # Re-label the filtered mask
        final_mask = np.zeros_like(labeled)
        for i, mask in enumerate(roi_masks, 1):
            final_mask[mask] = i
        
        # Insert master entry
        self.insert1({
            **key,
            'num_rois': len(roi_masks),
            'segmented_mask': final_mask
        })
        
        # Insert part entries (one per ROI)
        for roi_idx, mask in enumerate(roi_masks):
            # Compute center of mass
            cy, cx = ndimage.center_of_mass(mask)
            self.Roi.insert1({
                **key,
                'roi_idx': roi_idx,
                'mask': mask,
                'center_x': cx,
                'center_y': cy
            })
        
        print(f"Scan {key['scan_idx']}, params {key['seg_param_id']}: {len(roi_masks)} ROIs")

@schema
class Fluorescence(dj.Imported):
    definition = """
    -> Segmentation
    ---
    timestamps : <blob>    # time for each frame (seconds)
    """

    class Trace(dj.Part):
        definition = """
        -> master
        -> Segmentation.Roi
        ---
        trace : <blob>     # fluorescence trace (mean within ROI mask)
        """

    def make(self, key):
        # Get scan info and load movie
        file_name, fps = (Scan & key).fetch1('file_name', 'fps')
        movie = io.imread(DATA_DIR / file_name)
        n_frames = movie.shape[0]
        
        # Create time axis
        timestamps = np.arange(n_frames) / fps
        
        # Insert master entry
        self.insert1({**key, 'timestamps': timestamps})
        
        # Extract trace for each ROI
        for roi_key in (Segmentation.Roi & key).keys():
            mask = (Segmentation.Roi & roi_key).fetch1('mask')
            
            # Compute mean fluorescence within mask for each frame
            trace = np.array([frame[mask].mean() for frame in movie])
            
            self.Trace.insert1({**roi_key, 'trace': trace})
        
        n_rois = len(Segmentation.Roi & key)
        print(f"Extracted {n_rois} traces from {file_name}")

# Cleanup: drop schema for re-running
schema.drop(prompt=False)