Create

prepare_dataset.py

@@ -0,0 +1,286 @@
+#!/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()