prepare_dataset.py

#!/usr/bin/env python3

import os
import json
from pathlib import Path
import numpy as np
import cv2
from PIL import Image
import open3d as o3d
from tqdm import tqdm
from typing import Dict, List, Any
import shutil
import argparse

class FAFODatasetPreprocessor:
    """Preprocessor for FAFO dataset"""
    
    def __init__(self, input_dir: str, output_dir: str):
        self.input_dir = Path(input_dir)
        self.output_dir = Path(output_dir)
        self.metadata = {
            'num_samples': 0,
            'data_types': {
                'sensor_data': {'lidar': 0, 'gps': 0, 'imu': 0},
                'image_data': 0,
                '3d_data': 0,
                'task_data': 0
            }
        }

    def prepare_dataset(self):
        """Prepare the complete dataset"""
        print("Preparing FAFO dataset...")
        
        # Create directory structure
        self._create_directories()
        
        # Process each data type
        self._process_sensor_data()
        self._process_image_data()
        self._process_3d_data()
        self._process_task_data()
        
        # Save metadata
        self._save_metadata()
        
        print("Dataset preparation completed!")

    def _create_directories(self):
        """Create dataset directory structure"""
        directories = [
            'data/sensor_data/lidar',
            'data/sensor_data/gps',
            'data/sensor_data/imu',
            'data/image_data',
            'data/3d_data',
            'data/task_data'
        ]
        
        for dir_path in directories:
            (self.output_dir / dir_path).mkdir(parents=True, exist_ok=True)

    def _process_sensor_data(self):
        """Process all sensor data"""
        sensor_types = ['lidar', 'gps', 'imu']
        
        for sensor_type in sensor_types:
            print(f"Processing {sensor_type} data...")
            input_dir = self.input_dir / f'data/sensor_data/{sensor_type}'
            output_dir = self.output_dir / f'data/sensor_data/{sensor_type}'
            
            if not input_dir.exists():
                print(f"Warning: {input_dir} does not exist")
                continue
            
            for file_path in tqdm(list(input_dir.glob('*.json'))):
                try:
                    # Load and process data
                    with open(file_path, 'r') as f:
                        data = json.load(f)
                    
                    # Process based on sensor type
                    if sensor_type == 'lidar':
                        data = self._process_lidar_data(data)
                    elif sensor_type == 'gps':
                        data = self._process_gps_data(data)
                    elif sensor_type == 'imu':
                        data = self._process_imu_data(data)
                    
                    # Save processed data
                    output_path = output_dir / file_path.name
                    with open(output_path, 'w') as f:
                        json.dump(data, f, indent=2)
                    
                    self.metadata['data_types']['sensor_data'][sensor_type] += 1
                    
                except Exception as e:
                    print(f"Error processing {file_path}: {e}")

    def _process_image_data(self):
        """Process image data"""
        print("Processing image data...")
        input_dir = self.input_dir / 'data/image_data'
        output_dir = self.output_dir / 'data/image_data'
        
        if not input_dir.exists():
            print(f"Warning: {input_dir} does not exist")
            return
        
        for file_path in tqdm(list(input_dir.glob('*.jpg'))):
            try:
                # Load and process image
                image = Image.open(file_path)
                
                # Standardize image
                image = self._process_image(image)
                
                # Save processed image
                output_path = output_dir / file_path.name
                image.save(output_path, quality=95)
                
                self.metadata['data_types']['image_data'] += 1
                
            except Exception as e:
                print(f"Error processing {file_path}: {e}")

    def _process_3d_data(self):
        """Process 3D point cloud data"""
        print("Processing 3D data...")
        input_dir = self.input_dir / 'data/3d_data'
        output_dir = self.output_dir / 'data/3d_data'
        
        if not input_dir.exists():
            print(f"Warning: {input_dir} does not exist")
            return
        
        for file_path in tqdm(list(input_dir.glob('*.pcd'))):
            try:
                # Load and process point cloud
                pcd = o3d.io.read_point_cloud(str(file_path))
                
                # Process point cloud
                pcd = self._process_point_cloud(pcd)
                
                # Save processed point cloud
                output_path = output_dir / file_path.name
                o3d.io.write_point_cloud(str(output_path), pcd)
                
                self.metadata['data_types']['3d_data'] += 1
                
            except Exception as e:
                print(f"Error processing {file_path}: {e}")

    def _process_task_data(self):
        """Process task data"""
        print("Processing task data...")
        input_dir = self.input_dir / 'data/task_data'
        output_dir = self.output_dir / 'data/task_data'
        
        if not input_dir.exists():
            print(f"Warning: {input_dir} does not exist")
            return
        
        for file_path in tqdm(list(input_dir.glob('*.json'))):
            try:
                # Load and process task data
                with open(file_path, 'r') as f:
                    data = json.load(f)
                
                # Process task data
                data = self._process_task_definition(data)
                
                # Save processed data
                output_path = output_dir / file_path.name
                with open(output_path, 'w') as f:
                    json.dump(data, f, indent=2)
                
                self.metadata['data_types']['task_data'] += 1
                
            except Exception as e:
                print(f"Error processing {file_path}: {e}")

    def _process_lidar_data(self, data: Dict) -> Dict:
        """Process LiDAR data"""
        # Normalize ranges to meters
        if 'ranges' in data:
            data['ranges'] = [x / 100.0 for x in data['ranges']]
        
        # Ensure all required fields
        required_fields = ['timestamp', 'ranges', 'intensities', 'angles']
        for field in required_fields:
            if field not in data:
                data[field] = []
        
        return data

    def _process_gps_data(self, data: Dict) -> Dict:
        """Process GPS data"""
        # Ensure all required fields
        required_fields = ['timestamp', 'latitude', 'longitude', 'altitude']
        for field in required_fields:
            if field not in data:
                data[field] = 0.0
        
        return data

    def _process_imu_data(self, data: Dict) -> Dict:
        """Process IMU data"""
        # Ensure all required fields
        required_fields = ['timestamp', 'acceleration', 'angular_velocity', 'orientation']
        for field in required_fields:
            if field not in data:
                data[field] = [0.0, 0.0, 0.0]
        
        return data

    def _process_image(self, image: Image.Image) -> Image.Image:
        """Process image data"""
        # Resize to standard size
        image = image.resize((640, 480), Image.Resampling.LANCZOS)
        
        # Convert to RGB if needed
        if image.mode != 'RGB':
            image = image.convert('RGB')
        
        return image

    def _process_point_cloud(self, pcd: o3d.geometry.PointCloud) -> o3d.geometry.PointCloud:
        """Process point cloud data"""
        # Remove outliers
        pcd, _ = pcd.remove_statistical_outlier(nb_neighbors=20, std_ratio=2.0)
        
        # Downsample
        pcd = pcd.voxel_down_sample(voxel_size=0.05)
        
        return pcd

    def _process_task_definition(self, data: Dict) -> Dict:
        """Process task definition data"""
        # Ensure all required fields
        required_fields = ['task_type', 'parameters', 'annotations']
        for field in required_fields:
            if field not in data:
                data[field] = {}
        
        return data

    def _save_metadata(self):
        """Save dataset metadata"""
        # Update total samples
        self.metadata['num_samples'] = sum([
            sum(self.metadata['data_types']['sensor_data'].values()),
            self.metadata['data_types']['image_data'],
            self.metadata['data_types']['3d_data'],
            self.metadata['data_types']['task_data']
        ])
        
        # Save metadata
        metadata_path = self.output_dir / 'dataset_info.json'
        with open(metadata_path, 'w') as f:
            json.dump(self.metadata, f, indent=2)
        
        print(f"Dataset statistics:")
        print(f"Total samples: {self.metadata['num_samples']}")
        print("Data types:")
        for data_type, count in self.metadata['data_types'].items():
            if isinstance(count, dict):
                for subtype, subcount in count.items():
                    print(f"  - {data_type}/{subtype}: {subcount}")
            else:
                print(f"  - {data_type}: {count}")

def main():
    parser = argparse.ArgumentParser(description='Prepare FAFO dataset')
    parser.add_argument('--input_dir', type=str, required=True,
                      help='Input directory containing raw data')
    parser.add_argument('--output_dir', type=str, required=True,
                      help='Output directory for processed dataset')
    
    args = parser.parse_args()
    
    preprocessor = FAFODatasetPreprocessor(args.input_dir, args.output_dir)
    preprocessor.prepare_dataset()

if __name__ == '__main__':
    main()