update readme

README.md

@@ -8,43 +8,174 @@ license:
 # ADT Dataset
 
 ## Dataset Description
-This dataset contains Aria Digital Twin (ADT) sequences with various sensor data and annotations.
-
-## Usage Example
-```python
-from datasets import load_dataset
-import pandas as pd
-import json
-import io
-
-def deserialize_csv(csv_string):
-    return pd.read_csv(io.StringIO(csv_string))
-
-def deserialize_json(json_string):
-    return json.loads(json_string)
-
-# Load the dataset
-dataset = load_dataset("ariakang/ADT-test")
-sequence = dataset["{sequence_name}"]
-
-# Get list of available files
-files = list(zip(sequence["filename"], sequence["data_type"]))
-print("Available files:", files)
-
-# Load specific data
-for i, (filename, data_type, data) in enumerate(zip(
-    sequence["filename"], sequence["data_type"], sequence["data"]
-)):
-    if data_type == "csv":
-        df = deserialize_csv(data)
-        print(f"Loaded CSV {filename}: {len(df)} rows")
-    elif data_type in ["json", "jsonl"]:
-        json_data = deserialize_json(data)
-        print(f"Loaded JSON {filename}")
-    elif data_type == "vrs_info":
-        vrs_info = deserialize_json(data)
-        print(f"VRS files: {[f['filename'] for f in vrs_info]}")
-```
-
-## VRS Files
-VRS files are stored in: sequences/{sequence_name}/vrs_files/
+This dataset contains Aria Digital Twin (ADT) sequences with various sensor data and annotations, including 2D/3D bounding boxes, trajectories, eye gaze data, and VRS recordings.
+
+## Quick Start
+```python
+from adt_dataset_loader import ADTDatasetLoader
+
+# Load entire dataset
+loader = ADTDatasetLoader("ariakang/ADT-test")
+
+# Load specific sequence
+loader = ADTDatasetLoader("ariakang/ADT-test", sequence_name="Apartment_release_clean_seq131_M1292")
+```
+
+## Installation
+```bash
+# Install required packages
+pip install datasets pandas
+```
+
+## Dataset Structure
+Each sequence contains:
+- VRS Files:
+  - video.vrs
+  - synthetic_video.vrs
+  - segmentations.vrs
+  - depth_images.vrs
+- CSV Data:
+  - 2D/3D bounding boxes
+  - Aria device trajectories
+  - Eye gaze data
+  - Scene objects
+- JSON Data:
+  - Instance annotations
+  - Metadata
+- MPS Data:
+  - Eye gaze processing
+  - SLAM results
+
+## Flexible Loading Options
+
+### 1. Load Entire Dataset
+```python
+# Initialize loader with all sequences
+loader = ADTDatasetLoader("ariakang/ADT-test")
+
+# See available sequences and data types
+available_files = loader.get_available_files()
+print("Available files:", available_files)
+
+# Load all data types
+bbox_2d = loader.load_2d_bounding_boxes()
+bbox_3d = loader.load_3d_bounding_boxes()
+trajectory = loader.load_aria_trajectory()
+eyegaze = loader.load_eyegaze()
+metadata = loader.load_metadata()
+slam_data = loader.load_mps_slam()
+```
+
+### 2. Load Specific Sequences
+```python
+# Load a specific sequence
+loader = ADTDatasetLoader(
+    "ariakang/ADT-test",
+    sequence_name="Apartment_release_clean_seq131_M1292"
+)
+
+# Load data from this sequence
+bbox_2d = loader.load_2d_bounding_boxes()
+trajectory = loader.load_aria_trajectory()
+```
+
+### 3. Load Selected Data Types
+```python
+# Initialize loader for specific sequence
+loader = ADTDatasetLoader("ariakang/ADT-test", "Apartment_release_clean_seq131_M1292")
+
+# Load only 2D bounding boxes and VRS info
+bbox_2d = loader.load_2d_bounding_boxes()
+vrs_info = loader.get_vrs_files_info()
+
+# Get paths to specific VRS files
+video_vrs = [f for f in vrs_info if f['filename'] == 'video.vrs'][0]
+print(f"Video VRS path: {video_vrs['path']}")
+
+# Load only SLAM data
+slam_data = loader.load_mps_slam()
+closed_loop = slam_data['closed_loop']  # Get specific SLAM component
+```
+
+## Available Data Types and Methods
+
+### Main Data Types
+```python
+# Bounding Boxes and Trajectories
+bbox_2d = loader.load_2d_bounding_boxes()
+bbox_3d = loader.load_3d_bounding_boxes()
+trajectory = loader.load_aria_trajectory()
+
+# Eye Gaze and Scene Data
+eyegaze = loader.load_eyegaze()
+scene_objects = loader.load_scene_objects()
+
+# Metadata and Instances
+metadata = loader.load_metadata()
+instances = loader.load_instances()
+
+# MPS Data
+eye_gaze_data = loader.load_mps_eye_gaze()  # Returns dict with 'general' and 'summary'
+slam_data = loader.load_mps_slam()  # Returns dict with various SLAM components
+```
+
+### VRS Files
+```python
+# Get VRS file information
+vrs_info = loader.get_vrs_files_info()
+
+# Example: Access specific VRS file info
+for vrs_file in vrs_info:
+    print(f"File: {vrs_file['filename']}")
+    print(f"Path: {vrs_file['path']}")
+    print(f"Size: {vrs_file['size_bytes'] / 1024 / 1024:.2f} MB")
+```
+
+### Custom Loading
+```python
+# Load any file by name
+data = loader.load_file_by_name("your_file_name.csv")
+```
+
+## Data Format Examples
+
+### 2D Bounding Boxes
+```python
+bbox_2d = loader.load_2d_bounding_boxes()
+print(bbox_2d.columns)
+# Columns: ['object_uid', 'timestamp[ns]', 'x_min[pixel]', 'x_max[pixel]', 'y_min[pixel]', 'y_max[pixel]']
+```
+
+### Aria Trajectory
+```python
+trajectory = loader.load_aria_trajectory()
+print(trajectory.columns)
+# Columns: ['timestamp[ns]', 'x', 'y', 'z', 'qx', 'qy', 'qz', 'qw']
+```
+
+### MPS SLAM Data
+```python
+slam_data = loader.load_mps_slam()
+# Components:
+# - closed_loop: DataFrame with closed-loop trajectory
+# - open_loop: DataFrame with open-loop trajectory
+# - calibration: Calibration parameters
+```
+
+## Error Handling
+```python
+try:
+    data = loader.load_file_by_name("non_existent_file.csv")
+except ValueError as e:
+    print(f"Error: {e}")
+```
+
+## Notes
+- All CSV files are loaded as pandas DataFrames
+- JSON/JSONL files are loaded as Python dictionaries/lists
+- VRS files are not loaded into memory, only their metadata and paths are provided
+- Use `get_available_files()` to see all available data in your sequence
+
+## Repository Structure
+VRS files are stored in sequence-specific folders:
+`sequences/{sequence_name}/vrs_files/`

load_dataset.py

@@ -0,0 +1,182 @@
+import io
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Union
+
+import pandas as pd
+from datasets import load_dataset
+
+
+class ADTDatasetLoader:
+    """Loader for ADT Dataset from Hugging Face."""
+
+    def __init__(self, repo_id: str = "ariakang/ADT-test", sequence_name: str = None):
+        """
+        Initialize the dataset loader.
+
+        Args:
+            repo_id: Hugging Face repository ID
+            sequence_name: Specific sequence to load. If None, loads first available sequence
+        """
+        self.dataset = load_dataset(repo_id)
+
+        if sequence_name is None:
+            sequence_name = list(self.dataset.keys())[0]
+
+        self.sequence_name = sequence_name
+        self.sequence = self.dataset[sequence_name]
+
+        # Create a mapping of filenames to indices for faster access
+        self.file_index = {
+            filename: idx for idx, filename in enumerate(self.sequence["filename"])
+        }
+
+    def _deserialize_csv(self, csv_string: str) -> pd.DataFrame:
+        """Convert CSV string to DataFrame."""
+        return pd.read_csv(io.StringIO(csv_string))
+
+    def _deserialize_json(self, json_string: str) -> Union[Dict, List]:
+        """Convert JSON string to Python object."""
+        return json.loads(json_string)
+
+    def get_available_files(self) -> List[Dict[str, str]]:
+        """Get list of all available files and their types."""
+        return [
+            {"filename": filename, "type": dtype}
+            for filename, dtype in zip(
+                self.sequence["filename"], self.sequence["data_type"]
+            )
+        ]
+
+    def load_file_by_name(self, filename: str) -> Any:
+        """
+        Load specific file by name.
+
+        Args:
+            filename: Name of the file to load (e.g., "2d_bounding_box.csv")
+
+        Returns:
+            DataFrame for CSV files, dict/list for JSON files
+        """
+        if filename not in self.file_index:
+            raise ValueError(f"File {filename} not found in dataset")
+
+        idx = self.file_index[filename]
+        data_type = self.sequence["data_type"][idx]
+        data = self.sequence["data"][idx]
+
+        if data_type == "csv":
+            return self._deserialize_csv(data)
+        elif data_type in ["json", "jsonl"]:
+            return self._deserialize_json(data)
+        else:
+            return data
+
+    def load_2d_bounding_boxes(self) -> pd.DataFrame:
+        """Load 2D bounding box data."""
+        return self.load_file_by_name("2d_bounding_box.csv")
+
+    def load_3d_bounding_boxes(self) -> pd.DataFrame:
+        """Load 3D bounding box data."""
+        return self.load_file_by_name("3d_bounding_box.csv")
+
+    def load_aria_trajectory(self) -> pd.DataFrame:
+        """Load Aria device trajectory data."""
+        return self.load_file_by_name("aria_trajectory.csv")
+
+    def load_eyegaze(self) -> pd.DataFrame:
+        """Load eye gaze data."""
+        return self.load_file_by_name("eyegaze.csv")
+
+    def load_scene_objects(self) -> pd.DataFrame:
+        """Load scene objects data."""
+        return self.load_file_by_name("scene_objects.csv")
+
+    def load_instances(self) -> Dict:
+        """Load instances data."""
+        return self.load_file_by_name("instances.json")
+
+    def load_metadata(self) -> Dict:
+        """Load metadata."""
+        return self.load_file_by_name("metadata.json")
+
+    def load_mps_eye_gaze(self) -> Dict[str, Union[pd.DataFrame, Dict]]:
+        """Load MPS eye gaze data."""
+        return {
+            "general": self.load_file_by_name("mps/eye_gaze/general_eye_gaze.csv"),
+            "summary": self.load_file_by_name("mps/eye_gaze/summary.json"),
+        }
+
+    def load_mps_slam(self) -> Dict[str, Union[pd.DataFrame, List]]:
+        """Load MPS SLAM data."""
+        return {
+            "closed_loop": self.load_file_by_name(
+                "mps/slam/closed_loop_trajectory.csv"
+            ),
+            "open_loop": self.load_file_by_name("mps/slam/open_loop_trajectory.csv"),
+            "calibration": self.load_file_by_name("mps/slam/online_calibration.jsonl"),
+        }
+
+    def get_vrs_files_info(self) -> List[Dict]:
+        """Get information about VRS files."""
+        vrs_info = self.load_file_by_name("vrs_files_info.json")
+        return self._deserialize_json(vrs_info)
+
+
+def print_dataset_summary(data: Any, name: str):
+    """Print summary of loaded data."""
+    if isinstance(data, pd.DataFrame):
+        print(f"\n{name}:")
+        print(f"Shape: {data.shape}")
+        print("Columns:", list(data.columns))
+        print("Sample data:")
+        print(data.head(2))
+    elif isinstance(data, dict):
+        print(f"\n{name}:")
+        print("Keys:", list(data.keys()))
+    elif isinstance(data, list):
+        print(f"\n{name}:")
+        print(f"Number of items: {len(data)}")
+        if data:
+            print("First item sample:", data[0])
+
+
+def main():
+    """Example usage of the dataset loader."""
+    loader = ADTDatasetLoader()
+
+    print(f"Loading sequence: {loader.sequence_name}")
+
+    # Print available files
+    print("\nAvailable files:")
+    for file_info in loader.get_available_files():
+        print(f"- {file_info['filename']} ({file_info['type']})")
+
+    # Load and print summaries of all data types
+    print("\n=== Loading all data types ===")
+
+    # Bounding boxes
+    print_dataset_summary(loader.load_2d_bounding_boxes(), "2D Bounding Boxes")
+    print_dataset_summary(loader.load_3d_bounding_boxes(), "3D Bounding Boxes")
+
+    # Trajectory and eye gaze
+    print_dataset_summary(loader.load_aria_trajectory(), "Aria Trajectory")
+    print_dataset_summary(loader.load_eyegaze(), "Eye Gaze")
+
+    # Scene objects
+    print_dataset_summary(loader.load_scene_objects(), "Scene Objects")
+
+    # JSON data
+    print_dataset_summary(loader.load_instances(), "Instances")
+    print_dataset_summary(loader.load_metadata(), "Metadata")
+
+    # MPS data
+    print_dataset_summary(loader.load_mps_eye_gaze(), "MPS Eye Gaze")
+    print_dataset_summary(loader.load_mps_slam(), "MPS SLAM")
+
+    # VRS files info
+    print_dataset_summary(loader.get_vrs_files_info(), "VRS Files")
+
+
+if __name__ == "__main__":
+    main()

upload_to_HF.py

@@ -0,0 +1,227 @@
+import io
+import json
+import os
+from pathlib import Path
+
+import pandas as pd
+from datasets import Dataset, DatasetDict
+from huggingface_hub import HfApi
+
+
+def serialize_dataframe(df):
+    """Convert DataFrame to string."""
+    buffer = io.StringIO()
+    df.to_csv(buffer, index=False)
+    return buffer.getvalue()
+
+
+def load_csv_safely(file_path):
+    """Load CSV file and convert to string."""
+    if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
+        df = pd.read_csv(file_path)
+        return serialize_dataframe(df)
+    return ""
+
+
+def load_json_safely(file_path):
+    """Load JSON/JSONL file and convert to string."""
+    if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
+        with open(file_path, "r") as f:
+            if file_path.endswith(".jsonl"):
+                data = [json.loads(line) for line in f if line.strip()]
+            else:
+                try:
+                    data = json.load(f)
+                except json.JSONDecodeError:
+                    f.seek(0)
+                    data = [json.loads(line) for line in f if line.strip()]
+            return json.dumps(data)
+    return ""
+
+
+def upload_sequence(sequence_path, sequence_name, repo_id="ariakang/ADT-test"):
+    """Upload a single sequence to Hugging Face Hub."""
+
+    print(f"Starting upload process for sequence: {sequence_name}")
+
+    # Initialize Hugging Face API
+    api = HfApi()
+
+    # Upload VRS files first
+    print("Uploading VRS files...")
+    vrs_files = list(Path(sequence_path).glob("*.vrs"))
+    print(f"Found VRS files:", [f.name for f in vrs_files])
+
+    vrs_info = []
+    for vrs_file in vrs_files:
+        print(f"Uploading {vrs_file.name}...")
+        path_in_repo = f"sequences/{sequence_name}/vrs_files/{vrs_file.name}"
+
+        try:
+            api.upload_file(
+                path_or_fileobj=str(vrs_file),
+                path_in_repo=path_in_repo,
+                repo_id=repo_id,
+                repo_type="dataset",
+            )
+            print(f"Uploaded {vrs_file.name}")
+            vrs_info.append(
+                {
+                    "filename": vrs_file.name,
+                    "path": path_in_repo,
+                    "size_bytes": vrs_file.stat().st_size,
+                }
+            )
+        except Exception as e:
+            print(f"Error uploading {vrs_file.name}: {str(e)}")
+            raise
+
+    # Prepare sequence data
+    sequence_data = {
+        "data_type": [],  # To identify what type of data each entry is
+        "data": [],  # The serialized data
+        "filename": [],  # Original filename
+    }
+
+    # Load CSV files
+    csv_files = [
+        "2d_bounding_box.csv",
+        "3d_bounding_box.csv",
+        "aria_trajectory.csv",
+        "eyegaze.csv",
+        "scene_objects.csv",
+    ]
+
+    for file in csv_files:
+        file_path = os.path.join(sequence_path, file)
+        data = load_csv_safely(file_path)
+        if data:
+            sequence_data["data_type"].append("csv")
+            sequence_data["data"].append(data)
+            sequence_data["filename"].append(file)
+            print(f"Loaded {file}")
+
+    # Load JSON files
+    json_files = ["instances.json", "metadata.json"]
+    for file in json_files:
+        file_path = os.path.join(sequence_path, file)
+        data = load_json_safely(file_path)
+        if data:
+            sequence_data["data_type"].append("json")
+            sequence_data["data"].append(data)
+            sequence_data["filename"].append(file)
+            print(f"Loaded {file}")
+
+    # Load MPS folder data
+    mps_path = os.path.join(sequence_path, "mps")
+    if os.path.exists(mps_path):
+        # Eye gaze data
+        eye_gaze_path = os.path.join(mps_path, "eye_gaze")
+        if os.path.exists(eye_gaze_path):
+            data = load_csv_safely(os.path.join(eye_gaze_path, "general_eye_gaze.csv"))
+            if data:
+                sequence_data["data_type"].append("csv")
+                sequence_data["data"].append(data)
+                sequence_data["filename"].append("mps/eye_gaze/general_eye_gaze.csv")
+
+            data = load_json_safely(os.path.join(eye_gaze_path, "summary.json"))
+            if data:
+                sequence_data["data_type"].append("json")
+                sequence_data["data"].append(data)
+                sequence_data["filename"].append("mps/eye_gaze/summary.json")
+
+        # SLAM data
+        slam_path = os.path.join(mps_path, "slam")
+        if os.path.exists(slam_path):
+            for file in ["closed_loop_trajectory.csv", "open_loop_trajectory.csv"]:
+                data = load_csv_safely(os.path.join(slam_path, file))
+                if data:
+                    sequence_data["data_type"].append("csv")
+                    sequence_data["data"].append(data)
+                    sequence_data["filename"].append(f"mps/slam/{file}")
+
+            data = load_json_safely(os.path.join(slam_path, "online_calibration.jsonl"))
+            if data:
+                sequence_data["data_type"].append("jsonl")
+                sequence_data["data"].append(data)
+                sequence_data["filename"].append("mps/slam/online_calibration.jsonl")
+
+    # Add VRS file information
+    sequence_data["data_type"].append("vrs_info")
+    sequence_data["data"].append(json.dumps(vrs_info))
+    sequence_data["filename"].append("vrs_files_info.json")
+
+    # Create dataset
+    dataset_dict = DatasetDict({sequence_name: Dataset.from_dict(sequence_data)})
+
+    print("\nPushing dataset to hub...")
+    dataset_dict.push_to_hub(repo_id=repo_id, private=True)
+
+    # Update README
+    readme_content = """---
+language:
+- en
+license:
+- mit
+---
+
+# ADT Dataset
+
+## Dataset Description
+This dataset contains Aria Digital Twin (ADT) sequences with various sensor data and annotations.
+
+## Usage Example
+```python
+from datasets import load_dataset
+import pandas as pd
+import json
+import io
+
+def deserialize_csv(csv_string):
+    return pd.read_csv(io.StringIO(csv_string))
+
+def deserialize_json(json_string):
+    return json.loads(json_string)
+
+# Load the dataset
+dataset = load_dataset("ariakang/ADT-test")
+sequence = dataset["{sequence_name}"]
+
+# Get list of available files
+files = list(zip(sequence["filename"], sequence["data_type"]))
+print("Available files:", files)
+
+# Load specific data
+for i, (filename, data_type, data) in enumerate(zip(
+    sequence["filename"], sequence["data_type"], sequence["data"]
+)):
+    if data_type == "csv":
+        df = deserialize_csv(data)
+        print(f"Loaded CSV {filename}: {len(df)} rows")
+    elif data_type in ["json", "jsonl"]:
+        json_data = deserialize_json(data)
+        print(f"Loaded JSON {filename}")
+    elif data_type == "vrs_info":
+        vrs_info = deserialize_json(data)
+        print(f"VRS files: {[f['filename'] for f in vrs_info]}")
+```
+
+## VRS Files
+VRS files are stored in: sequences/{sequence_name}/vrs_files/
+"""
+
+    api.upload_file(
+        path_or_fileobj=readme_content.encode(),
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+
+    return f"https://huggingface.co/datasets/{repo_id}"
+
+
+if __name__ == "__main__":
+    sequence_path = "/Users/ariak/Documents/projectaria_tools_adt_data/Apartment_release_clean_seq131_M1292"
+    sequence_name = "Apartment_release_clean_seq131_M1292"
+    repo_url = upload_sequence(sequence_path, sequence_name)
+    print(f"Dataset uploaded successfully to: {repo_url}")