labdata 0.0.3__py3-none-any.whl

labdata/schema/histology.py

@@ -0,0 +1,309 @@
+from .general import *
+
+@dataschema
+class Atlas(dj.Manual):
+    definition = '''
+    atlas_id : varchar(12)
+    ---
+    atlas_description = NULL: varchar(156)
+    atlas_url = NULL: varchar(156)
+    atlas_citation = NULL: varchar(156)
+    '''
+    class Region(dj.Part):
+        definition = '''
+        -> master
+        region_acronym : varchar(12)
+        ---
+        region_name: varchar(256)
+        region_id: int
+        region_atlas_id: int
+        region_level: int
+        region_graph_depth = NULL: int
+        region_graph_order = NULL: int
+        structure_id_path: varchar(80)
+        color_hex = NULL: char(8)
+        '''
+
+@dataschema
+class FixedBrain(dj.Imported):
+    '''Whole brain histology or fixed tissue. 
+    The class provides methods for:
+    - Loading brain image data via get() method
+    - Viewing brain data in napari via napari_open() method
+    
+    Definition
+    ----------
+    file_path : str
+        Path to the brain imaging data file
+    num_channels : int
+        Number of imaging channels
+    width : int 
+        Image width in pixels
+    height : int
+        Image height in pixels
+    um_per_pixel : array
+        Microns per pixel resolution in each dimension
+    hardware : str
+        Imaging hardware/microscope used
+    '''
+    definition = '''
+    -> Dataset
+    ---
+    -> [nullable] File
+    num_channels = NULL          : smallint
+    width = NULL                 : int
+    height = NULL                : int
+    um_per_pixel = NULL          : blob
+    hardware  = NULL             : varchar(56)
+    '''
+    def get(self):
+        '''Get the brain imaging data.
+        
+        Returns
+        -------
+        array or list
+            If single brain, returns array containing brain data.
+            If multiple brains, returns list of arrays.
+        '''
+        brains = []
+        for s in self:
+            brains.append(open_zarr((File() & s).get()[0]))
+        if len(brains)==1:
+            return brains[0] # like fetch1
+        return brains
+    
+    def napari_open(self, **kwargs):
+        '''Open brain data in napari viewer.
+        
+        Opens the brain imaging data in a napari viewer window for visualization.
+        Only one brain can be opened at a time.
+        
+        Pass channel_axis = 1 to open with color
+        Returns
+        -------
+        napari.Viewer
+            The napari viewer instance displaying the brain data
+            
+        Raises
+        ------
+        AssertionError
+            If more than one brain is selected
+        '''
+        assert len(self) == 1, 'Open only one brain at a time.'
+        from labdata.stacks import napari_open
+        napari_open(self.get(),**kwargs)
+
+
+@analysisschema
+class FixedBrainTransformParameters(dj.Manual):
+    '''Table for storing manual transformation parameters for fixed brain images.
+    
+    The parameters are used by FixedBrainTransform to generate transformed versions
+    of the original brain images for analysis and visualization.
+
+    Definition
+    ----------
+    transform_id : int
+        ID for this set of transform parameters (default 0)
+    downsample : array-like
+        Downsampling factors for [T,C,X,Y] dimensions
+    rotate : array-like  
+        [Z,Y,X] rotation angles and [flipx,flipy] boolean flags
+    crop : array-like
+        Crop ranges [[start,end,step], ...] for each dimension
+    transpose : array-like
+        Order to transpose dimensions, e.g. [2,1,3,0]
+    cast : str
+        Data type to cast output to (e.g. 'uint16')
+    '''
+    definition = '''
+    -> FixedBrain
+    transform_id = 0 : smallint
+    ---
+    downsample = NULL : blob       # [T, C, X, Y]
+    rotate = NULL     : blob       # [Z, Y, X, flipx, flipy]
+    crop = NULL       : blob       # [[START,END,STEP],None,None,None] what to crop 
+    transpose = NULL  : blob       # [2,1,3,0]  order to transpose so it is a coronal section
+    cast = NULL       : varchar(8) # datatype of the downsampled data
+    '''
+
+@analysisschema
+class FixedBrainTransform(dj.Computed):
+    '''Table for storing transformed fixed brain images.
+    
+    This class computes and stores transformed versions of fixed brain images based on 
+    parameters from FixedBrainTransformParameters. 
+ 
+    The transformed images are stored as TIFF files in the analysis storage location.
+    
+    Definition
+    ----------
+    file_path : str
+        Path to the transformed TIFF file in analysis storage
+    storage : str
+        Storage location name (default: 'analysis')
+    um_per_pixel : array-like
+        Resolution in microns per pixel for each dimension
+    shape : array-like 
+        Shape of the transformed stack [T,C,X,Y]
+    hemisphere : str
+        Which hemisphere is included ('left', 'right', or 'both')
+        
+    Methods
+    -------
+    transform(key)
+        Apply transformations specified in parameters to generate transformed stack
+            
+        Returns
+        -------
+        ndarray
+            The transformed image stack
+        
+    get()
+        Load and return the transformed image stack(s)
+        
+        Returns
+        -------
+        list
+            List of transformed image stacks as numpy arrays
+    '''
+    definition = '''
+    -> FixedBrain
+    -> FixedBrainTransformParameters
+    ---
+    -> AnalysisFile
+    um_per_pixel = NULL : blob
+    shape = NULL        : blob
+    hemisphere = NULL   : varchar(5)  # left, right, both
+    '''
+
+    def transform(self,key):
+        '''Transform fixed brain image according to parameters.
+        
+        Applies transformations specified in FixedBrainTransformParameters to generate
+        a transformed stack. If the transform has already been computed, loads and 
+        returns the existing transformed stack from storage.
+
+        Transformation order:
+        1. Downsample if specified
+        2. Rotate if specified 
+        3. Crop if specified
+        4. Transpose dimensions if specified
+
+        Parameters
+        ----------
+        key : dict
+            Primary key specifying which FixedBrainTransformParameters to use
+            
+        Returns
+        -------
+        ndarray
+            The transformed image stack. Shape depends on transformation parameters.
+            
+        '''
+        if len(self & key):
+            key = (self & key).fetch1()
+            print(f'Transform has been computed. Fetching from {key["file_path"]}.')
+            apath = (AnalysisFile() & key).get()[0]
+
+            from tifffile import imread 
+            stack = imread(apath)
+            return stack
+        stack = (FixedBrain() & key).get()
+        params = (FixedBrainTransformParameters() & key).fetch1()
+        from labdata.stacks import rotate_stack,downsample_stack
+        if not params['downsample'] is None:
+            stack = downsample_stack(stack,params['downsample'])
+        if not params['rotate'] is None:
+            stack = rotate_stack(stack,*params['rotate'])
+        if not params['crop'] is None:
+            A,B,C,D = params['crop']
+            if A is None:
+                A = [0,stack.shape[0],1]
+            if B is None:
+                B = [0,stack.shape[1],1]
+            if C is None:
+                C = [0,stack.shape[2],1]
+            if D is None:
+                D = [0,stack.shape[3],1]
+            stack = stack[A[0]:A[1]:A[2],
+                          B[0]:B[1]:B[2],
+                          C[0]:C[1]:C[2],
+                          D[0]:D[1]:D[2],]
+        if not params['transpose'] is None:
+            stack = stack.transpose(params['transpose'])
+        return stack
+    
+    def get(self):
+        '''Load the transformed brain stacks.
+        
+        Returns
+        -------
+        ndarray or list
+            If only one stack exists, returns a single ndarray.
+            If multiple stacks exist, returns a list of ndarrays.
+        '''
+        brains = []
+        from tifffile import imread
+        for s in self:
+            brains.append(imread((AnalysisFile() & s).get()[0]))
+        if len(brains)==1:
+            return brains[0] # like fetch1
+        return brains
+
+    def make(self,k):
+        par = (FixedBrainTransformParameters() & k).fetch1()
+        origpar = (FixedBrain() & k).fetch1()
+
+        downsample_par = np.array(par['downsample'])[np.array([0,2,3])]
+        stack = self.transform(k)
+        um_per_pixel = list(origpar['um_per_pixel']/downsample_par)
+
+        folder_path = (((Path(prefs['local_paths'][0])
+                            /k['subject_name']))
+                            /k['session_name'])/f'brain_transform_{k["transform_id"]}'
+        filepath = folder_path/f'stack_{um_per_pixel[0]}um.ome.tif'
+        folder_path.mkdir(exist_ok=True)
+        from tifffile import imwrite  # saving in tiff so it is easier to read
+        imwrite(filepath,stack, 
+                imagej = True,
+                metadata={'axes': 'ZCYX'}, 
+                compression ='zlib',
+                compressionargs = {'level': 6})
+        added = AnalysisFile().upload_files([filepath],dict(subject_name = k['subject_name'],
+                                                session_name = k['session_name'],
+                                                dataset_name = f'brain_transform_{k["transform_id"]}'))[0]
+
+        to_add = dict(k,
+                      um_per_pixel = um_per_pixel,
+                      shape = stack.shape,
+                      **added)
+        self.insert1(to_add)
+        # save to tiff and upload to the analysis bucket
+
+@analysisschema
+class FixedBrainTransformAnnotation(dj.Manual):
+    '''Table for storing manual annotations of brain locations.
+    
+    This table stores manually annotated points in transformed brain volumes, such as:
+    - Probe tracks
+    - Injection sites 
+    - Anatomical landmarks
+    - Region boundaries
+    
+    Each annotation consists of:
+    - annotation_name: Description of what is being annotated
+    - annotation_type: Category of annotation (e.g. 'probe_track', 'injection')
+    - xyz: Array of x,y,z coordinates marking the annotation location
+    
+    The coordinates are in pixels relative to the transformed brain volume.
+    '''
+    definition = '''
+    -> FixedBrainTransform
+    annotation_id : int
+    ---
+    annotation_name : varchar(36)
+    annotation_type : varchar(36)
+    xyz : blob
+    '''
+    

labdata/schema/onephoton.py

@@ -0,0 +1,93 @@
+from .general import *
+from .procedures import *
+from .histology import *
+
+@dataschema
+class Widefield(dj.Imported):
+    '''Table for widefield one-photon imaging data.
+    
+    This table stores metadata about widefield imaging recordings including:
+    - Frame dimensions and counts
+    - Frame rate
+    - Optical parameters (magnification, objective, pixel scale)
+    - Reference to raw data file
+    - Imaging software details
+    
+    The table includes a Part table for storing different projections of the data
+    (mean, std, var, max).
+    '''
+    definition = '''
+    -> Dataset
+    ---
+    n_channels             : smallint            # number of channels
+    n_frames               : int                 # duration of the recording
+    width                  : int                 # width of each frame
+    height                 : int                 # height of each frame
+    frame_rate             : double              # frame rate
+    -> File                                      # path to the stack
+    magnification = NULL   : double              # magnification
+    objective_angle = NULL : double              # angle
+    objective = NULL       : varchar(32)         # objective
+    um_per_pixel = NULL    : blob                # XY scale conversion factors
+    imaging_software       : varchar(32)         # software and version
+    '''
+    
+    def open(self):
+        '''Opens the widefield imaging data file.
+        
+        Returns
+        -------
+        zarr.Array
+            The opened zarr array containing the widefield imaging data.
+            Data is stored in a compressed zarr format with dimensions:
+            [frames, channels, height, width]
+        '''
+        if len(self) != 1:
+            raise(ValueError(f'Select only one dataset {self.proj().fetch(as_dict = True)}.'))
+        fname = (File() & (Widefield & self.proj()) & 'file_path LIKE "%.zarr.zip"').get()[0]
+        return open_zarr(fname)
+
+    class Projection(dj.Part):
+        '''Part table for storing projections of widefield imaging data.
+        
+        This table stores projections (mean, std, var, max) of the 
+        widefield imaging data.
+        
+        Attributes
+        ----------
+        proj_name : enum
+            Type of projection ('mean', 'std', 'var', 'max')
+        proj : longblob
+            The projection data array
+        '''
+        definition = '''
+        -> master
+        proj_name           : enum('mean','std','var','max')                  
+        ---
+        proj      : longblob
+    '''
+        
+@dataschema
+class Miniscope(dj.Imported):
+    definition = '''
+    -> Dataset
+    ---
+    n_channels             : smallint            # number of channels
+    n_frames               : int                 # duration of the recording
+    width                  : int                 # width of each frame
+    height                 : int                 # height of each frame
+    frame_rate             : double              # frame rate
+    -> File                                      # path to the stack
+    device = NULL          : varchar(32)         # miniscope device
+    power = NULL           : blob                # power used per channel
+    lens_tuning            : int                 # EWL tuning (focus)
+    sensor_gain = NULL     : int                 # gain of the imaging sensor
+    um_per_pixel = NULL    : blob                # XY scale conversion factors
+    -> [nullable] Atlas.Region                   # target region (or the center of the imaging plane)
+    '''
+    def open(self):
+        if len(self) != 1:
+            raise(ValueError(f'Select only one dataset {self.proj().fetch(as_dict = True)}.'))
+        fname = (File() & self).get()[0]
+        return open_zarr(fname)
+    

labdata/schema/procedures.py

@@ -0,0 +1,102 @@
+from .general import *
+
+@dataschema
+class Weighing(dj.Manual):
+    '''Table for tracking subject weights.
+    
+    This table stores weight measurements for experimental subjects. Each entry includes:
+    - Subject
+    - Date and time of weighing
+    - Weight in grams
+    
+    '''
+    definition = """
+    -> Subject
+    weighing_datetime : datetime
+    ---
+    weight : float  # (g)
+    """
+
+@dataschema
+class ProcedureType(dj.Lookup):
+    '''Table defining types of experimental procedures.
+    
+    This lookup table enumerates the different types of experimental procedures, including:
+    - Surgical procedures (surgery, implants, craniotomy)
+    - Behavioral procedures (handling, training) 
+    - Other manipulations (injections)
+    
+    The procedure types are used by the Procedure table to categorize and track all
+    procedures performed.
+    '''
+    definition = """
+    procedure_type : varchar(52)       #  Defines procedures that are not an experimental session
+    """
+    contents = zip(['surgery',
+                    'chronic implant',
+                    'chronic explant', 
+                    'injection',
+                    'window implant',
+                    'window replacement',
+                    'handling',
+                    'training',
+                    'craniotomy'])
+
+@dataschema
+class Procedure(dj.Manual):
+    '''Table for tracking experimental procedures performed on subjects.
+    
+    Each procedure entry includes:
+    - Subject
+    - ProcedureType
+    - Date and time
+    - Lab member who performed it
+    - Optional metadata: weight, and notes
+    '''
+    definition = """
+    -> Subject
+    -> ProcedureType
+    procedure_datetime            : datetime
+    ---
+    -> LabMember
+    procedure_metadata = NULL     : longblob   
+    -> [nullable] Weighing
+    -> [nullable] Note
+    """
+
+@dataschema
+class Watering(dj.Manual):
+    '''Table for tracking water administration to subjects.
+    
+    This table records water consumed, including:
+    - Subject receiving water
+    - Date and time
+    - Volume of water, in microliters
+    
+    '''
+    definition = """
+    -> Subject
+    watering_datetime : datetime
+    ---
+    water_volume : float  # (uL)
+    """
+    
+@dataschema
+class WaterRestriction(dj.Manual):
+    definition = """
+    -> Subject
+    water_restriction_start_date : date
+    ---
+    -> LabMember
+    water_restriction_end_date : date
+   -> Weighing
+    """
+
+@dataschema
+class Death(dj.Manual):
+    definition = """
+    -> Subject
+    ---
+    death_date :          datetime       # death date
+    -> [nullable] Note
+    """

labdata/schema/tasks.py

@@ -0,0 +1,66 @@
+from .general import *
+from .procedures import Watering
+@analysisschema
+class DecisionTask(dj.Imported): # imported because if comes from data but there is no 'make'
+    '''Table for behavioral decision task data.
+    
+    This table serves as a general schema for decision-making behavioral tasks,
+    abstracting common features that can be inherited by specific task tables
+    defined in plugins. Each entry includes:
+    - Total trial counts (assisted, self-performed, initiated, with choice)
+    - Performance metrics (rewarded, punished trials)
+    - Optional reference to water intake during session
+    
+    The table includes a Part table (TrialSet) that stores detailed sets of trials within a session, 
+    dependent on the modality or condition and includes including:
+    - Trial conditions and modalities
+    - Performance metrics per condition
+    - Timing data (initiation times, reaction times) 
+    - Response and subject feedback values
+    - Stimulus parameters (intensity, block)
+    
+    This data can be used to compute:
+    - Psychometric curves
+    - Learning curves
+    - Reaction time distributions
+    - Choice biases and strategies
+    - ...
+    
+    The schema is designed to be flexible and is meant to be populated by specific task tables (defined as plugins) 
+    while maintaining a consistent interface for analysis and visualization.
+    '''
+    definition = '''
+    -> Dataset
+    ---
+    n_total_trials              : int            # number of trials in the session
+    n_total_assisted = NULL     : int            # number of assisted trials in the session
+    n_total_performed = NULL    : int            # number of self-performed trials
+    n_total_initiated = NULL    : int            # number of initiated trials
+    n_total_with_choice = NULL  : int            # number of self-initiated with choice
+    n_total_rewarded = NULL     : int            # number of rewarded trials
+    n_total_punished = NULL     : int            # number of punished trials
+    -> [nullable] Watering                       # water intake during the session (ml) 
+    '''
+        
+    class TrialSet(dj.Part):
+        definition = '''
+        -> master
+        trialset_description     : varchar(54) # e.g. trial modality, unique condition
+        ---
+        n_trials                 : int         # total number of trials
+        n_performed              : int         # number of self-performed trials
+        n_with_choice            : int         # number of self-initiated trials with choice 
+        n_correct                : int         # number of correct trials
+        performance_easy = NULL  : float       # performance on easy trials
+        performance = NULL       : float       # performance on all trials
+        trial_num                : longblob    # trial number because TrialSets can be intertwined
+        initiation_times = NULL  : longblob    # time between trial start and stim onset
+        assisted = NULL          : longblob    # wether the trial was assisted
+        response_values = NULL   : longblob    # left=1;no response=0; right=-1        
+        correct_values = NULL    : longblob    # correct = 1; no_response  = NaN; wrong = 0        
+        intensity_values = NULL  : longblob    # value of the stim (left-right)
+        reaction_times = NULL    : longblob    # between onset of the response period and reporting  
+        block_values = NULL      : longblob    # block number for each trial
+        '''
+
+