code/dataset_convert.py

"""
DatasetConverter - A utility for processing EgoSim dataset for machine learning.
Image loading is slow thus a conversion to mp4 or hdf5 is benefitial.

This script provides an example pipeline to convert raw EgoSim simulation
data into standardized formats suitable for machine learning applications. The 
converter handles image sequences, SMPL pose parameters, and metadata to generate:
- MP4 videos with standardized dimensions
- HDF5 datasets for efficient storage (optional)
- CSV metadata files for sequences
- Processed SMPL body model data with joint positions
"""
import os
import pickle
import signal
import time
import traceback
from pathlib import Path
from typing import Tuple, List

import cv2
import h5py
import numpy as np
import pandas as pd
import torch
from smplx import SMPLX
from tqdm import trange
import subprocess


class DatasetConverter:

    def __init__(self, label_idx,
                 image_size: Tuple[int, int],
                 images_root: Path, # H, W
                 airsim_rec_root: Path,
                 video_output_root: Path,
                 hdf5_output_root: Path,
                 csv_output_root: Path,
                 smpl_root: Path,
                 smpl_out_root: Path,
                 smplx_model_path: Path,
                 max_sequence_length: int = 150,
                 save_as_mp4: bool = True,
                 save_as_hdf5: bool = False
                 ):
        """
        Initialize the DatasetConverter for transforming raw AirSim data to a format suitable for training models.

        This converter handles various data processing tasks:
        - Converting raw images to mp4 videos with standardized dimensions
        - Converting SMPL pose parameters to usable joint positions
        - Saving sequence data in HDF5 format (optional)
        - Creating CSV files with sequence metadata
        
        Parameters
        ----------
        label_idx : dict
            The Babel action dictionary containing segment information with keys like 'amass_path', 'start_s', 'end_s', 'seg_id', etc.
        
        image_size : Tuple[int, int]
            Desired output size for images/videos as (height, width) in pixels.
        
        images_root : Path
            Root directory containing the raw input images.
        
        airsim_rec_root : Path
            Root directory containing AirSim recording data (airsim_rec.txt files).
        
        video_output_root : Path
            Directory where converted mp4 videos will be saved.
        
        hdf5_output_root : Path
            Directory where HDF5 files of image sequences will be saved.
        
        csv_output_root : Path
            Directory where CSV files with sequence metadata will be saved.
        
        smpl_root : Path
            Root directory containing original SMPL model parameters.
        
        smpl_out_root : Path
            Directory where processed SMPL sequence data will be saved.
        
        smplx_model_path : Path
            Path to the directory containing SMPLX model files.
        
        max_sequence_length : int, optional
            Maximum number of frames to include in a sequence, default is 150.

        save_as_mp4 : bool, optional
            Whether to save sequences as MP4 videos, default is True.
        
        save_as_hdf5 : bool, optional
            Whether to save sequences as HDF5 files, default is False.
        """
        self.label_idx = label_idx
        self.image_size = image_size
        self.airsim_rec_root = airsim_rec_root
        self.images_root = images_root
        self.video_output_root = video_output_root
        self.hdf5_output_root = hdf5_output_root
        self.max_sequence_length = max_sequence_length
        self.csv_output_root = csv_output_root
        self.smpl_root = smpl_root
        self.smpl_out_root = smpl_out_root
        self.interrupt_caught = False
        self.airsim_rec_cache = {}
        self.should_save_as_mp4 = save_as_mp4
        self.should_save_as_hdf5 = save_as_hdf5

        self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
        self.body_model_female = SMPLX(str(smplx_model_path / "SMPLX_FEMALE.npz"),
                                       batch_size=1,
                                       gender='female',
                                       num_betas=16,
                                       num_expression_coeffs=10,
                                       ).to(self.device)
        self.body_model_male = SMPLX(str(smplx_model_path / "SMPLX_MALE.npz"),
                                     batch_size=1,
                                     gender='male',
                                     num_betas=16,
                                     num_expression_coeffs=10).to(self.device)

    def load_images_from_disk(self, img_path):
        """Loads image from disk as jpg."""
        img_path = self.images_root / img_path.parent / "images" / img_path.name
        try:
            image = cv2.imread(str(img_path))
            image = cv2.resize(image, (self.image_size[1], self.image_size[0]))
        except Exception as e:
            print(f"Failed to load {img_path} and resize image. Returning empty image", e)
            return np.zeros((self.image_size[0], self.image_size[1], 3), dtype=np.uint8)

        return image

    def load_images(self, img_paths):
        """Loads images from disk as jpg files."""
        images = []
        for img_path in img_paths:
            image = self.load_images_from_disk(img_path)
            images.append(image)
        return images

    def save_to_hdf5(self, image_paths: List[Path], seg_id: str, view: str):
        timea = time.time()
        stacked_images = np.stack(self.load_images(image_paths), axis=0)
        timeb = time.time()
        # Save the images as hdf5
        dataset_name = image_paths[0].parts[0] + ".hdf5"
        participant_name = image_paths[0].parent.parent.name
        sequence = image_paths[0].parent.name
        os.makedirs(self.hdf5_output_root, exist_ok=True)
        try:
            with h5py.File(self.hdf5_output_root / dataset_name, 'a', libver='latest') as hdf5_file:
                seg_group = hdf5_file.require_group(participant_name).require_group(sequence).require_group(seg_id)
                if view in seg_group:
                    return
                    # seg_group[view][...] = stacked_images
                else:
                    seg_group.create_dataset(view, data=stacked_images, dtype="uint8")
        except Exception as e:
            print(f"Error saving to hdf5: {e}, on {self.hdf5_output_root / dataset_name} with seg_id {seg_id} and view {view}")
            raise e
        timec = time.time()
        print(f"Time to load images: {timeb - timea}, time to save hdf5: {timec - timeb}")

    def valid_image(self, img_path):
        """checks if the image exists and is not 0 size."""
        if not img_path.exists():
            print("Image does not exist", img_path)
            return False
        if os.path.getsize(img_path) == 0:
            print("Image is 0 size", img_path)
            return False
        return True

    def save_as_mp4(self, image_paths: List[Path], seg_id: str, view: str):
        sequence_part = Path(*image_paths[0].parts[-4:-1])
        output_dir = self.video_output_root / sequence_part / seg_id
        # Save the images as mp4
        os.makedirs(output_dir, exist_ok=True)
        image_file_list_path = output_dir / f"image_file_list_{view}.txt"
        video_output_path = output_dir / f"{view}.mp4"

        cap = cv2.VideoCapture(str(video_output_path))
        length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        cap.release()
        if length == len(image_paths):
            print("Video (with same number of frames) already exists, skipping")
            return

        with open(image_file_list_path, 'w') as file:
            image_paths = [images_root / sequence_part / "images" / image_path.name for image_path in image_paths]
            image_paths_str = "\n".join([f"file '{self.images_root / image_path}'" for image_path in image_paths if self.valid_image(self.images_root / image_path)])
            file.write(image_paths_str)
        
        # This command uses ffmpeg to create a video from the images. It expects that ffmpeg is compiled with hardware accelerated nvenc support for faster video encoding.
        # If not available change this line to use the software encoder
        command =  f"ffmpeg -hide_banner -loglevel error -f concat -r 30 -y -safe 0 -i '{image_file_list_path}' -c:v hevc_nvenc -vf 'scale={self.image_size[1]}:{self.image_size[0]}' -aspect 1:1 -preset p7 -cq:v 1 -pix_fmt yuv420p '{video_output_path}'"
        # command =  f"ffmpeg -hide_banner -loglevel error -f concat -r 30 -y -safe 0 -i '{image_file_list_path}' -c:v libx265 -vf 'scale={self.image_size[1]}:{self.image_size[0]}' -aspect 1:1 -preset slow -crf 18 -pix_fmt yuv420p '{video_output_path}'"

        try:
            # Execute the command, capturing stdout and stderr
            result = subprocess.run(command, shell=True, check=True, text=True, stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            # Print and write stderr to a file if an error occurs
            print(f"An error occurred: {e.stderr}")
            with open("error_files.txt", "a") as error_file:
                error_file.write(f"Error in ffmpeg: {e.stderr}, on {image_file_list_path} with command: {command}\n")

        os.remove(image_file_list_path)

        # read the video and check the number of frames it has
        cap = cv2.VideoCapture(str(video_output_path))
        length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        cap.release()
        if length != len(image_paths):
            print(f"Video {video_output_path} has {length} frames, should have {len(image_paths)}")

    def save_smpl_sequence(self, airsim_rec: pd.DataFrame, sequence_path: Path, vehicle_name: str, seg_id: str):
        # save np arrays as npz file
        out_file = (smpl_out_root / sequence_path / seg_id).with_suffix(".npz")
        out_file.parent.mkdir(parents=True, exist_ok=True)
        # check if output file already exists and contains "joint_positions" key
        if out_file.exists():
            try:
                npz = np.load(out_file)
                if "joint_positions" in npz:
                    print(f"Skipping {out_file} as it already exists.")
                    return
            except Exception as e:
                print(f"Error loading {out_file}: {e}")


        # load smpl data
        smpl_path = self.smpl_root / sequence_path
        smpl_path = smpl_path.with_suffix(".npz")
        smpl_data = np.load(smpl_path, allow_pickle=True)

        ts = airsim_rec[airsim_rec["VehicleName"] == vehicle_name]["TimeStampAnimationS"]

        def timestamps_to_idx(ts, smpl_data):
            fps = smpl_data["mocap_frame_rate"]
            idx = (ts * fps).astype(int)
            return idx


        idx = timestamps_to_idx(ts, smpl_data)
        idx_len = idx.shape[0]
        idx = idx[idx < smpl_data["poses"].shape[0]]
        if idx.shape[0] - idx_len > 2:
            print(f"Warning: More than 2 frames were removed from the smpl data. {idx_len - idx.shape[0]} frames were removed.")

        poses = smpl_data["poses"][idx]
        root_orient = smpl_data["root_orient"][idx]
        trans = smpl_data["trans"][idx]
        betas = smpl_data["betas"]
        gender = smpl_data["gender"]

        joint_positions = np.zeros((idx.shape[0], 127, 3))
        poses_torch = torch.from_numpy(poses[:, 3:66]).float().to(self.device)
        betas_torch = torch.from_numpy(betas).float().to(self.device)
        for i in range(idx.shape[0]):
            if smpl_data["gender"] == "male":
                bm = self.body_model_male
            elif smpl_data["gender"] == "female":
                bm = self.body_model_female
            else:
                raise ValueError("Body model can either be male or female.")
            bp = {
                "body_pose": poses_torch[i].unsqueeze(0),
                "betas": betas_torch.unsqueeze(0),
            }
            with torch.no_grad():
                joint_positions[i] = bm.forward(**bp, return_verts=False, use_only_num_joints=-1).joints.cpu().numpy()

        np.savez(out_file,
                 poses=poses,
                 root_orient=root_orient,
                 trans=trans,
                 betas=betas,
                 gender=gender,
                 joint_positions=joint_positions,
                 )


    def save_segment_csv(self, sequence_path, seg_id, airsim_rec, airsim_rec_other_vehicles, vehicle_name):
        csv_out_path = self.csv_output_root / sequence_path / seg_id
        csv_out_path.mkdir(parents=True, exist_ok=True)
        airsim_rec_all = pd.concat([airsim_rec, airsim_rec_other_vehicles])
        airsim_rec_all = airsim_rec_all.sort_index()

        self.save_smpl_sequence(airsim_rec_all, sequence_path, vehicle_name, seg_id)

        if airsim_rec_all.shape[0] == 0:
            print("WARNING: airsim_rec_all is empty: saving to empty csv: ", csv_out_path / "airsim_rec.csv")
        airsim_rec_all.to_csv(csv_out_path / "airsim_rec.csv", index=False)

    def convert_sample(self, idx: int):
        sequence_path = self.label_idx["amass_path"][idx]
        start_s = self.label_idx['start_s'][idx]
        end_s = self.label_idx['end_s'][idx]
        seg_id = self.label_idx['seg_id'][idx]
        chunk = self.label_idx['chunk_n'][idx]


        airsim_rec_path = self.airsim_rec_root / sequence_path

        # load csv with pandas
        if not airsim_rec_path.exists():
            print(f"No airsim_rec.txt found for {sequence_path} in {seg_id}. Skipping Segment of length {start_s} {end_s} ({end_s-start_s})")
            # append filename to error file
            with open("error_files.txt", "a") as file:
                file.write(f"No airsim_rec.txt found for {sequence_path} in {seg_id}. Skipping Segment of length {start_s} {end_s} ({end_s-start_s})\n")
            return

        airsim_rec_fp = airsim_rec_path / 'airsim_rec.txt'
        if airsim_rec_fp not in self.airsim_rec_cache:
            airsim_rec = pd.read_csv(airsim_rec_fp, sep="\t", engine="c", low_memory=False)
            self.airsim_rec_cache[airsim_rec_fp] = airsim_rec.copy()
        else:
            airsim_rec = self.airsim_rec_cache[airsim_rec_fp].copy()

        # vehicle name of character
        seq_path_split = sequence_path.split("/")
        vehicle_name = seq_path_split[-3] + "#" + seq_path_split[-2]

        max_time = airsim_rec['TimeStampAnimationS'].max()
        orig_airsim_rec = airsim_rec #.copy()
        vehicle_mask = airsim_rec['VehicleName'] == vehicle_name
        time_mask = (airsim_rec["TimeStampAnimationS"] >= start_s) & (airsim_rec["TimeStampAnimationS"] < end_s)
        airsim_rec = airsim_rec[vehicle_mask & time_mask]

        frames = len(airsim_rec)
        if frames == 0:
            print(f"No frames found for {sequence_path} in {seg_id}. Skipping Segment of length {start_s} {end_s} ({end_s-start_s}. Vehicle max: {max_time})")
            # append filename to error file
            with open("error_files.txt", "a") as file:
                file.write(f"No images in sequence {sequence_path} {seg_id} start: {start_s} end: {end_s}, airsim_rec_path: {airsim_rec_path}\n")
            return

        end = min(airsim_rec.index[-1] + 1, orig_airsim_rec.shape[0] - 1)
        orig_airsim_rec_window = orig_airsim_rec.iloc[airsim_rec.index[0]:end]
        airsim_rec_other_vehicles = orig_airsim_rec_window[orig_airsim_rec_window["VehicleName"] != vehicle_name]



        subsampling = 1
        if frames > self.max_sequence_length:
            if self.label_idx['scale_factor'][idx] > 1.0:
                # print("Scalling factor > 1.0, subsampling: ")
                # print("Rows before: ", len(airsim_rec))
                # take every second row
                subsampling = int(self.label_idx['scale_factor'][idx])
                airsim_rec = airsim_rec.iloc[::subsampling]
                frames = len(airsim_rec)
                # print("Rows after: ", len(airsim_rec))

            print(
                f"Warning: More than {self.max_sequence_length} frames found ({frames}). Only using the first {self.max_sequence_length}, airsim_rec_path: {airsim_rec_path}. Start: {start_s} End: {end_s} Vehicle max: {max_time})")
            with open("error_files.txt", "a") as file:
                file.write(
                    f"Warning: More than {self.max_sequence_length} frames found ({frames}). Only using the first {self.max_sequence_length}, airsim_rec_path: {airsim_rec_path}. Start: {start_s} End: {end_s} Vehicle max: {max_time})\n")
            airsim_rec = airsim_rec.head(self.max_sequence_length)
            frames = self.max_sequence_length

        # save airsim_rec.csv for current sequence
        if chunk != 0:
            seg_id = f"{seg_id}_chunk{chunk:02d}"

        # saving subset airsim_rec to csv

        self.save_segment_csv(sequence_path, seg_id, airsim_rec, airsim_rec_other_vehicles, vehicle_name)

        image_paths = airsim_rec["ImageFile"].dropna().str.split(';').explode().tolist()
        for view in ["socket1", "socket2", "socket3", "socket4", "socket5", "socket6"]:
            sequence_paths = [Path(sequence_path) / image_path.replace(".ppm", ".jpg") for image_path in image_paths if
                                view in image_path]

            if len(sequence_paths) > 150:
                print(f"Warning: More than 150 images found ({len(sequence_paths)}). Only using the first 150, airsim_rec_path: {airsim_rec_path}. Start: {start_s} End: {end_s} Vehicle max: {max_time})")
                with open("error_files.txt", "a") as file:
                    file.write(
                        f"Warning: More than 150 images found ({len(sequence_paths)}). Only using the first 150, airsim_rec_path: {airsim_rec_path}. Start: {start_s} End: {end_s} Vehicle max: {max_time})\n")
                sequence_paths = sequence_paths[:150]

            # continue if video path already exists
            sequence_part = Path(*sequence_paths[0].parts[-4:-1])
            output_dir = self.video_output_root / sequence_part / seg_id / f"{view}.mp4"
            if output_dir.exists() and output_dir.stat().st_size != 0:
                # continue if video already exists
                continue

            # Save as HDF5 if requested
            if self.should_save_as_hdf5:
                self.save_to_hdf5(sequence_paths, seg_id, view)

            # Save as MP4 if requested
            if self.should_save_as_mp4:
                self.save_as_mp4(sequence_paths, seg_id, view)


    def signal_handler(self, signal, frame):
        print('Interrupt received, finishing the current operation before exiting...')
        self.interrupt_caught = True

    def convert_dataset(self):
        # Set the signal handler for SIGINT (Ctrl+C)
        signal.signal(signal.SIGINT, self.signal_handler)

        for i in trange(0, len(self.label_idx["amass_path"])):
            if self.interrupt_caught:
                print("Interrupt caught, exiting...")
                break
            try:
                self.convert_sample(i)
            except Exception as e:
                print(f"An error occurred: {e}, on {self.label_idx['amass_path'][i]} with seg_id {self.label_idx['seg_id'][i]}")
                traceback.print_exc()
                with open("error_files.txt", "a") as file:
                    file.write(f"An error occurred: {e}, on {self.label_idx['amass_path'][i]} with seg_id {self.label_idx['seg_id'][i]}\n")


if __name__ == "__main__":

    dataset_paths = [r'babel_v1.0/train_label_60.pkl', r'babel_v1.0/val_label_60.pkl', r'babel_v1.0/test_label_60.pkl']
    for dataset_path in dataset_paths:
        with open(dataset_path, 'rb') as f:
            dataset_split = pickle.load(f)

        # these two paths might be the same
        images_root = Path("path to images root")
        airsim_rec_root = Path("paths to airsim rec root")
        
        # optional to save videos
        video_output_root = Path("path to output video root")
        # optional to save hdf5
        hdf5_output_root = Path("path to output hdf5 root")
        
        # Path where CSV metadata files will be stored
        csv_output_root = Path("/path/to/output/csv")
        
        # Path to directory containing SMPL models
        smpl_root = Path("/path/to/amass/smpl/models") 
        
        # Path where processed SMPL sequence data will be saved
        smpl_out_root = Path("/path/to/output/smpl/sequences")
        
        # Path to directory containing SMPLX model files
        smplx_model_path = Path("/path/to/smplx/models")

        converter = DatasetConverter(dataset_split,
                                    (224, 224),
                                    images_root,
                                    airsim_rec_root,
                                    video_output_root,
                                    hdf5_output_root,
                                    csv_output_root,
                                    smpl_root,
                                    smpl_out_root,
                                    smplx_model_path)

        converter.convert_dataset()