Updated README.

README.md

@@ -18,104 +18,120 @@ size_categories:
 
 # MICrONS Functional Activity Dataset & Reader
 
-This repository contains a curated portion of the MICrONS (Multi-Scale Networked Analysis of Cellular Responding Order) dataset. It consists of functional calcium imaging data from the visual cortex of mice in response to various visual stimuli (natural clips (Clip) and parametric videos (Monet2, Trippy)).  
-Videos have been downsampled to match neural activity scan frequency with frame choice corresponding to the the frame appearing at least 66ms before scan time.  
+This repository contains a curated portion of the MICrONS (Multi-Scale Networked Analysis of Cellular Responding Order) dataset. It consists of functional calcium imaging data from the visual cortex of mice in response to various visual stimuli: natural clips (`Clip`) and parametric videos (`Monet2`, `Trippy`).
+
+Videos have been downsampled to match the neural activity scan frequency, with each frame corresponding to the stimulus frame appearing at least 66 ms before scan time. Neural responses are linearly interpolated at each stimulus frame timestamp to align with the video.
+
 The data is organized into a highly efficient, indexed HDF5 format, allowing for rapid cross-session analysis based on either stimulus identity or brain anatomy.
 
+---
+
 ## 📊 Dataset Overview
 
-- Sessions: 14 sessions of registered neural activity.
-- Stimuli: Three categories of videos (Clip, Monet2, Trippy) identified by unique condition hashes.
-- Neural Data: Calcium traces (responses) from thousands of neurons across multiple visual areas (V1, AL, LM, RL).
-- Behavioral Data: Synchronized treadmill speed and pupil radius.
-- Eye Tracking: Pupil center coordinates (x, y) for gaze analysis.
+| Property | Detail |
+|---|---|
+| Sessions | 14 sessions of registered neural activity |
+| Stimuli | 3 categories (`Clip`, `Monet2`, `Trippy`) identified by unique condition hashes |
+| Neural Data | Calcium traces from thousands of neurons across V1, LM, RL, AL |
+| Behavioral Data | Synchronized treadmill speed and pupil size (major/minor radius) |
+| Eye Tracking | Pupil center coordinates (x, y) for gaze analysis |
+
+---
 
+## 🗂️ Internal HDF5 Structure
+
+The file is organized to minimize redundancy: each unique video stimulus is stored once under `/videos/` and linked to every trial across all sessions via HDF5 SoftLinks. The `/sessions/` group is the source of truth for all neural and behavioral recordings.
 ```text
 root/
-├── 📂 BRAIN_AREAS/                              # Anatomical Index
+├── 📂 BRAIN_AREAS/                              # Anatomical index (SoftLinks only)
 │   └── 📂 <area_name>/                          # e.g., V1, AL, LM, RL
 │       └── 🔗 <session_id>                      -> /sessions/<session_id>
 │
-├── 📂 SESSIONS/                                 # Primary Data Storage
+├── 📂 SESSIONS/                                 # Primary neural data storage
 │   └── 📂 <session_id>/                         # e.g., 4_7, 5_6
-│       ├── 📂 META/                             # Session-wide Metadata
-│       │   ├── 📂 AREA_INDICES/                 # Pre-calculated neuron masks
-│       │   │   └── 📄 <area_name>               [Dataset: (N_area_neurons,)]
-│       │   ├── 📄 brain_areas                   [Dataset: (N_total_neurons,)]
-│       │   ├── 📄 coordinates                   [Dataset: (N_total_neurons, 3)]
-│       │   ├── 📄 unit_ids                      [Dataset: (N_total_neurons,)]
-│       │   ├── 📄 condition_hashes              [Dataset: (N_trials,)]
-│       │   └── (Attr) fps                       [Float: Sampling rate]
-│       └── 📂 TRIALS/                           # Individual trial folders
-│           └── 📂 <trial_idx>/                  # Chronological trial index
-│               ├── 📄 responses                 [Dataset: (N_neurons, F_trial)]
-│               ├── 📄 behavior                  [Dataset: (2, F_trial)]
-│               ├── 📄 pupil_center              [Dataset: (2, F_trial)]
-│               └── (Attr) condition_hash        [String: Reference to video]
+│       ├── 📂 META/                             # Session-wide metadata
+│       │   ├── 📂 AREA_INDICES/                 # Pre-computed neuron index masks per area
+│       │   │   └── 📄 <area_name>               [Dataset: (N_area_neurons,), int]
+│       │   ├── 📄 brain_areas                   [Dataset: (N_neurons,), bytes — area label per neuron]
+│       │   ├── 📄 coordinates                   [Dataset: (N_neurons, 3), float — motor coordinates x/y/z]
+│       │   ├── 📄 unit_ids                      [Dataset: (N_neurons,), int — unique neuron IDs]
+│       │   ├── 📄 condition_hashes              [Dataset: (N_trials,), bytes — hash per trial, in order]
+│       │   └── (Attr) fps                       [Float — scan acquisition rate]
+│       └── 📂 TRIALS/                           # One group per trial, indexed chronologically
+│           └── 📂 <trial_idx>/
+│               ├── 📄 responses                 [Dataset: (N_neurons, F), float — ΔF/F calcium traces]
+│               ├── 📄 treadmill                 [Dataset: (F,), float — running speed in cm/s]
+│               ├── 📄 pupil                     [Dataset: (4, F), float — rows: x, y, major_r, minor_r]
+│               ├── 📄 stim_times               [Dataset: (F,), float — stimulus frame timestamps in seconds]
+│               └── (Attr) condition_hash        [String — identifies the video shown in this trial]
 │
-├── 📂 TYPES/                                    # Stimulus Category Index
+├── 📂 TYPES/                                    # Stimulus category index (SoftLinks only)
 │   └── 📂 <stim_type>/                          # e.g., Clip, Monet2, Trippy
 │       └── 🔗 <encoded_hash>                    -> /videos/<encoded_hash>
 │
-└── 📂 VIDEOS/                                   # Stimulus Library (Saved once)
-    └── 📂 <encoded_hash>/                       # Encoded version of condition_hash
-        ├── 📄 clip                              [Dataset: (Frames, H, W)]
-        ├── 📂 INSTANCES/                        # Reverse-index to trials
+└── 📂 VIDEOS/                                   # Stimulus library — each video stored once
+    └── 📂 <encoded_hash>/                       # URL-encoded condition hash (/ → %2F)
+        ├── 📄 clip                              [Dataset: (F, H, W), uint8 — grayscale frames]
+        ├── 📄 times                             [Dataset: (F,), float — relative frame timestamps in seconds, starting at 0]
+        ├── 📂 INSTANCES/                        # Reverse index: all trials that showed this video
         │   └── 🔗 <session_id>_tr<trial_idx>    -> /sessions/<session_id>/trials/<trial_idx>
-        └── (Attr) original_hash                 [String: The raw hash]
-        └── (Attr) type                          [String: Stimulus type]
+        ├── (Attr) original_hash                 [String — raw unencoded hash]
+        ├── (Attr) type                          [String — one of: Clip, Monet2, Trippy]
+        │
+        │   # Clip-specific attributes/datasets:
+        ├── (Attr) movie_name                    [String]
+        ├── (Attr) short_movie_name              [String]
+        ├── (Attr) duration                      [Float — clip duration in seconds]
+        ├── (Attr) fps                           [Float — original stimulus frame rate]
+        │
+        │   # Monet2-specific attributes/datasets:
+        ├── 📄 directions                        [Dataset: (N_orientations,), float — grating directions in degrees]
+        ├── 📄 onsets                            [Dataset: (N_orientations,), float — onset times per grating]
+        ├── (Attr) duration                      [Float]
+        ├── (Attr) ori_coherence                 [Float — orientation coherence parameter]
+        ├── (Attr) fps                           [Float]
+        │
+        │   # Trippy-specific attributes/datasets:
+        ├── (Attr) temp_freq                     [Float — temporal frequency in Hz]
+        ├── (Attr) spatial_freq                  [Float — spatial frequency in cycles/degree]
+        ├── (Attr) duration                      [Float]
+        └── (Attr) fps                           [Float]
 ```
 
-## ⚙️ Setup & Installation
-
-There are two ways of accessing the contents of this repo. 
+### Key design notes
 
-### 1. Clone the Repository
-Since the dataset is stored as a large HDF5 file (.h5), you must have Git LFS installed.
+- **`/brain_areas/` and `/types/`** contain only SoftLinks — no data. They serve as fast lookup indices.
+- **`/videos/<hash>/instances/`** allows reverse lookup: given a video, find every session and trial that presented it.
+- **`condition_hashes`** in session metadata are stored in trial order and may contain duplicates (the same video can be shown multiple times per session).
+- **`pupil`** rows are ordered `[x, y, major_r, minor_r]` consistently across all sessions.
+- **`stim_times`** are absolute timestamps in seconds; `times` inside `/videos/` are relative (starting at 0), computed as `stim_times - stim_times.min()`.
 
-```bash
-# Install git-lfs if you haven't already
-git lfs install
-
-# Clone the repository
-git clone https://huggingface.co/datasets/NeuroBLab/MICrONS
-cd microns-functional
-
-# Install required packages
-
-pip install - r requirements.txt
-```
-### 2. Programmatic Access (Python)
+---
 
-If you don't want to clone the full repository, you can download the reader and the data file directly into your Python script using the huggingface_hub library.
+## ⚙️ Setup & Installation
 
-**1. Install the library**
+### Option 1 — Clone the repository
 
+Since the dataset is stored as a large HDF5 file, Git LFS is required.
 ```bash
-pip install huggingface_hub h5py numpy
+git lfs install
+git clone https://huggingface.co/datasets/NeuroBLab/MICrONS
+cd MICrONS
+pip install -r requirements.txt
 ```
 
-**2. Download and Run**
-
+### Option 2 — Programmatic download (no clone)
 ```python
 import sys
 import importlib.util
 from huggingface_hub import hf_hub_download
 
-# 1. Define Repository Info
 REPO_ID = "NeuroBLab/MICrONS"
-DATA_FILENAME = "microns.h5"
-READER_FILENAME = "reader.py"
 
 print("Downloading files from Hugging Face...")
+reader_path = hf_hub_download(repo_id=REPO_ID, filename="reader.py")
+data_path   = hf_hub_download(repo_id=REPO_ID, filename="microns.h5")
 
-# 2. Download the Reader script
-reader_path = hf_hub_download(repo_id=REPO_ID, filename=READER_FILENAME)
-
-# 3. Download the HDF5 Data file (this handles Git LFS automatically)
-data_path = hf_hub_download(repo_id=REPO_ID, filename=DATA_FILENAME)
-
-# 4. Dynamically import the MicronsReader class from the downloaded file
 spec = importlib.util.spec_from_file_location("reader", reader_path)
 reader_module = importlib.util.module_from_spec(spec)
 sys.modules["reader"] = reader_module
@@ -123,85 +139,94 @@ spec.loader.exec_module(reader_module)
 
 from reader import MicronsReader
 
-# 5. Use the reader
 with MicronsReader(data_path) as reader:
-    print("File downloaded and reader initialized!")
-    reader.print_structure(max_items=1)
+    reader.print_structure(max_items=2)
 ```
 
-## 🛠️ Reader API Demo
-
-The MicronsReader class is designed to handle the hierarchical structure of the HDF5 file transparently, including internal hash encoding and SoftLink navigation.
-
-### 1. Initialize the Reader
+---
 
-The best way to use the reader is via a context manager to ensure the HDF5 file handle is closed properly.
+## 🛠️ Reader API
 
+### Initialize
 ```python
 from reader import MicronsReader
 
-path = "microns.h5"
-
-with MicronsReader(path) as reader:
-    # Your analysis code here
+with MicronsReader("microns.h5") as reader:
+    # all calls go here
     pass
 ```
 
-### 2. Overview of Dataset Structure
-
-To see the internal organization of the file without loading the actual data into RAM:
-
+### Explore structure
 ```python
-with MicronsReader(path) as reader:
-    reader.print_structure(max_items=3)
+with MicronsReader("microns.h5") as reader:
+    # Tree view — SoftLinks are shown without dereferencing by default
+    reader.print_structure(max_items=3, follow_links=False)
 ```
 
-### 3. Exploring Stimuli and Sessions
-
-You can query the database by session, stimulus type, or brain area.
-
+### Query available metadata
 ```python
-with MicronsReader(path) as reader:
-    # List available stimulus types
-    types = reader.get_video_types() # ['Clip', 'Monet2', 'Trippy']
+with MicronsReader("microns.h5") as reader:
+    # All stimulus types in the file
+    types = list(reader.f['types'].keys())          # ['Clip', 'Monet2', 'Trippy']
 
-    # Get all unique hashes for a specific type
+    # All hashes for a given stimulus type
     monet_hashes = reader.get_hashes_by_type('Monet2')
 
-    # Find which videos were shown in a specific session
-    session_hashes = reader.get_hashes_by_session('4_7', return_unique=True)
+    # All (or unique) hashes shown in a session
+    all_hashes    = reader.get_hashes_by_session('4_7')
+    unique_hashes = reader.get_hashes_by_session('4_7', return_unique=True)
 
-    # Check which brain areas are recorded in a session
-    areas = reader.get_available_brain_areas('4_7') # ['V1', 'AL', 'LM', 'RL']
+    # Brain areas recorded in a session, or all areas in the file
+    areas_in_session = reader.get_available_brain_areas('4_7')  # ['AL', 'LM', 'RL', 'V1']
+    all_areas        = reader.get_available_brain_areas()
 ```
 
-### 4. Loading Full Data (Stimulus + Responses)
-
-The get_full_data_by_hash method is the most powerful tool in the library. It aggregates the video pixels and every recorded neural/behavioral repeat across all 14 sessions.
+### Load video + all associated trials
 
+`get_full_data_by_hash` is the primary access method. It aggregates the video and every neural/behavioral trial across all sessions that presented that stimulus.
 ```python
 target_hash = "0JcYLY6eaQxNgD0AqyHf"
 
-with MicronsReader(path) as reader:
-    # Load all data for this video, filtering for V1 neurons only
+with MicronsReader("microns.h5") as reader:
+    # Optionally filter responses to a single brain area
     data = reader.get_full_data_by_hash(target_hash, brain_area='V1')
 
-    if data:
-        print(f"Video Shape: {data['clip'].shape}") # (Frames, H, W)
-        
-        for trial in data['trials']:
-            print(f"Session: {trial['session']}")
-            print(f"Neural Responses: {trial['responses'].shape}") # (Neurons, Frames)
-            print(f"Running Speed: {trial['behavior'][0, :]}")
+    print(data['clip'].shape)       # (F, H, W)  — grayscale video frames
+    print(data['stim_type'])        # e.g. 'Clip'
+
+    for trial in data['trials']:
+        print(trial['session'])             # e.g. '4_7'
+        print(trial['trial_idx'])           # e.g. '12'
+        print(trial['responses'].shape)     # (N_V1_neurons, F)
+        print(trial['treadmill'].shape)     # (F,)   — running speed in cm/s
+        print(trial['pupil'].shape)         # (4, F) — rows: x, y, major_r, minor_r
+        print(trial['stim_times'].shape)    # (F,)   — absolute timestamps in seconds
+```
+
+### Load only neural responses
+```python
+with MicronsReader("microns.h5") as reader:
+    trials = reader.get_responses_by_hash(target_hash, brain_area='LM')
+    # Returns: [{'session': str, 'trial_idx': str, 'responses': np.array}, ...]
+```
+
+### Direct single-trial access
+```python
+with MicronsReader("microns.h5") as reader:
+    trial = reader.get_trial('4_7', trial_idx=12, brain_area='V1')
+    print(trial['responses'].shape)   # (N_V1_neurons, F)
+    print(trial['stim_times'])        # absolute timestamps for this trial
 ```
 
-## 📂 Internal HDF5 Structure
+### Load only the video
+```python
+with MicronsReader("microns.h5") as reader:
+    clip, stim_type = reader.get_video_data("0JcYLY6eaQxNgD0AqyHf")
+    print(clip.shape)    # (F, H, W)
+    print(stim_type)     # 'Clip'
+```
 
-The database is structured to minimize redundancy by storing the video "Clip" once and linking it to multiple "Trials" across sessions.
-- `/videos/`: Contains the raw video arrays and links to their session instances.
-- `/sessions/`: The "source of truth" for neural activity, organized by session ID and trial index.
-- `/types/`: An index group for fast lookup of videos by category (Clip, Monet2, etc.).
-- `/brain_areas/`: An index group linking brain regions (V1, LM...) to the sessions where they were recorded.
+---
 
 ## 📝 Citation