MTMC_Tracking_2025/eval/utils/io_utils.py

import os
import re
import json
import argparse
import logging
from typing import Any, Dict
from utils.classes import CLASS_LIST, map_sub_class_to_primary_class, map_class_id_to_class_name


logging.basicConfig(format="%(asctime)s - %(message)s", datefmt="%y/%m/%d %H:%M:%S", level=logging.INFO)



class ValidateFile(argparse.Action):
    """
    Custom argparse action to validate file paths.
    """

    def __call__(self, parser, namespace, values, option_string=None):
        # Validate the file path format
        file_path_pattern = r"^[a-zA-Z0-9_\-\/.#+]+$"
        if not re.match(file_path_pattern, values):
            parser.error(f"Invalid file path: {values}")

        # Check if the file exists
        if not os.path.exists(values):
            parser.error(f"File {values} does NOT exist.")

        # Check if the file is readable
        if not os.access(values, os.R_OK):
            parser.error(f"File {values} is NOT readable.")

        # Set the validated file path in the namespace
        setattr(namespace, self.dest, values)


def validate_file_path(input_string: str) -> str:
    """
    Validates whether the input string matches a file path pattern

    :param str input_string: input string
    :return: validated file path
    :rtype: str
    ::

        file_path = validate_file_path(input_string)
    """
    file_path_pattern = r"^[a-zA-Z0-9_\-\/.#+]+$"
    if re.match(file_path_pattern, input_string):
        return input_string
    else:
        raise ValueError(f"Invalid file path: {input_string}")


def sanitize_string(input_string: str) -> str:
    """
    Sanitizes an input string

    :param str input_string: input string
    :return: sanitized string
    :rtype: str
    ::

        sanitized_string = sanitize_string(input_string)
    """
    # Allow alphanumeric characters, dots, slashes, underscores, hashes, and dashes
    return re.sub(r"[^a-zA-Z0-9\._/#-]", "_", input_string)


def make_dir(dir_path: str) -> None:
    """
    Safely create a directory.
    """
    valid_dir_path = validate_file_path(dir_path)
    if os.path.islink(valid_dir_path):
        raise ValueError(f"Directory path {dir_path} must not be a symbolic link.")
    
    try:
        if not os.path.isdir(valid_dir_path):
            os.makedirs(valid_dir_path)
    except OSError as e:
        raise ValueError(f"Failed to create directory {dir_path}: {e}")

def load_json_from_file(file_path: str) -> Any:
    """
    Safely loads JSON data from a file.
    """
    valid_file_path = validate_file_path(file_path)
    try:
        with open(valid_file_path, "r") as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON format in file {file_path}: {e}")
    except Exception as e:
        raise ValueError(f"An error occurred while loading file {file_path}: {e}")


def split_files_per_scene(gt_path: str, pred_path: str, output_base_dir: str, scene_id_2_scene_name: Dict[int, str], num_frames_to_eval: int = 9000):
    """
    Splits GT and Pred files per scene, saving them into separate directories.

    :param gt_path: Path to the ground truth JSON file.
    :param pred_path: Path to the predictions JSON file.
    :param output_base_dir: Base directory to save split files.
    """
    # Create output base directory
    os.makedirs(output_base_dir, exist_ok=True)

    gt_scenes = set()
    pred_scenes = set()
    # convert to int
    valid_scene_ids = set(int(scene_id) for scene_id in scene_id_2_scene_name.keys())


    # Process GT data
    scene_gt_writers = {}
    with open(gt_path, "r") as gt_file:
        for line in gt_file:
            line_split = line.split(" ")
            scene_id = int(line_split[0])
            gt_scenes.add(scene_id)
            if scene_id not in scene_gt_writers:
                os.makedirs(os.path.join(output_base_dir, f"scene_{scene_id}"), exist_ok=True)
                scene_gt_writers[scene_id] = open(os.path.join(output_base_dir, f"scene_{scene_id}", "gt.txt"), "w")
            scene_gt_writers[scene_id].write(line)

    # Close all GT writers
    for writer in scene_gt_writers.values():
        writer.close()

    # convert gt_scenes to a list and sort it
    gt_scenes = list(gt_scenes)
    gt_scenes.sort()
    logging.info(f"Found scenes {gt_scenes} in ground truth.")

    # Process Pred data
    scene_pred_writers = {}
    with open(pred_path, "r") as pred_file:
        for line in pred_file:
            line_split = line.split(" ")
            
            # Validate line length
            if len(line_split) != 11:
                raise ValueError(f"Found incorrect entry in predictions. Each entry should have 11 elements: (scene_id class_id object_id frame_id x y z width length height yaw)")

            # Validate scene id
            scene_id = int(line_split[0])
            if scene_id not in valid_scene_ids:
                raise ValueError(f"Found incorrect scene id in predictions: {scene_id}. Valid scene ids are: {valid_scene_ids}, defined by the scene_id_2_scene_name json file")

            # Validate class id
            class_id = int(line_split[1])
            if class_id not in map_class_id_to_class_name:
                raise ValueError(f"Found incorrect class id in predictions: {class_id}. Valid class ids are: {map_class_id_to_class_name.keys()}")
            
            # Validate object id
            object_id = int(line_split[2])
            if object_id < 0:
                raise ValueError(f"Found incorrect object id in predictions: {object_id}. Object id should be positive.")
            
            # Validate frame id
            frame_id = int(line_split[3])
            if frame_id < 0:
                raise ValueError(f"Found incorrect frame id in predictions: {frame_id}. Frame id should be 0 or positive.")
            if int(frame_id) >= int(num_frames_to_eval):
                continue

            pred_scenes.add(scene_id)
            if scene_id not in scene_pred_writers:
                os.makedirs(os.path.join(output_base_dir, f"scene_{scene_id}"), exist_ok=True)
                scene_pred_writers[scene_id] = open(os.path.join(output_base_dir, f"scene_{scene_id}", "pred.txt"), "w")
            scene_pred_writers[scene_id].write(line)

    # Close all Pred writers
    for writer in scene_pred_writers.values():
        writer.close()

    # convert gt_scenes to a list and sort it
    pred_scenes = list(pred_scenes)
    pred_scenes.sort()
    logging.info(f"Found scenes {pred_scenes} in predictions.")


def split_files_per_class(gt_path: str, pred_path: str, output_base_dir: str, confidence_threshold: float = 0.0, num_frames_to_eval:int = 20000, ground_truth_frame_offset_secs: float = 0.0, fps: float = 30.0):
    """
    Splits GT and Pred files per class, saving them into separate directories.

    :param gt_path: Path to the ground truth JSON file.
    :param pred_path: Path to the predictions JSON file.
    :param output_base_dir: Base directory to save split files.
    """
    # Create output base directory
    os.makedirs(output_base_dir, exist_ok=True)

    gt_classes = set()
    pred_classes = set()

    # Process GT data
    class_gt_writers = {}
    with open(gt_path, "r") as gt_file:
        for line in gt_file:
            line_split = line.split(" ")
            class_id = int(line_split[1])
            class_name = map_class_id_to_class_name[class_id]
            gt_classes.add(class_name)
            if class_name not in class_gt_writers:
                os.makedirs(os.path.join(output_base_dir, class_name), exist_ok=True)
                class_gt_writers[class_name] = open(os.path.join(output_base_dir, class_name, "gt.txt"), "w")
            class_gt_writers[class_name].write(line)

    # Close all GT writers
    for writer in class_gt_writers.values():
        writer.close()

    # convert gt_classes to a list and sort it
    gt_classes = list(gt_classes)
    gt_classes.sort()
    logging.info(f"Found classes {gt_classes} in ground truth.")

    # Process Pred data
    class_pred_writers = {}
    with open(pred_path, "r") as pred_file:
        for line in pred_file:
            line_split = line.split(" ")
            class_id = int(line_split[1])
            class_name = map_class_id_to_class_name[class_id]
            pred_classes.add(class_name)
            if class_name not in class_pred_writers:
                os.makedirs(os.path.join(output_base_dir, class_name), exist_ok=True)
                class_pred_writers[class_name] = open(os.path.join(output_base_dir, class_name, "pred.txt"), "w")
            class_pred_writers[class_name].write(line)

    # Close all Pred writers
    for writer in class_pred_writers.values():
        writer.close()

    # convert gt_classes to a list and sort it
    pred_classes = list(pred_classes)
    pred_classes.sort()
    logging.info(f"Found classes {pred_classes} in predictions.")


def get_no_of_objects_per_scene(gt_path: str, scene_id_2_scene_name: Dict[int, str]):
    """
    Get the number of objects per scene in the ground truth file.
    """
    no_of_objects_per_scene = {}
    with open(gt_path, "r") as gt_file:
        for line in gt_file:
            line_split = line.split(" ")
            scene_id = line_split[0]
            if scene_id not in scene_id_2_scene_name:
                continue
            scene_name = scene_id_2_scene_name[scene_id]
            if scene_name not in no_of_objects_per_scene:
                no_of_objects_per_scene[scene_name] = 0
            no_of_objects_per_scene[scene_name] += 1
    return no_of_objects_per_scene


def split_files_by_sensor(gt_path: str, pred_path: str, output_base_dir: str, map_camera_name_to_bev_name, confidence_threshold, num_frames_to_eval):
    """
    Splits GT and Pred files by sensor and saves them into separate directories.
    :param gt_path: Path to the ground truth JSON file.
    :param pred_path: Path to the predictions JSON file.
    :param output_base_dir: Base directory to save split files.
    """
    # Create output base directory
    os.makedirs(output_base_dir, exist_ok=True)

    # Set to keep track of unique sensor IDs
    gt_sensors = set()
    pred_sensors = set()

    # Create writers for GT data
    sensor_gt_writers = {}
    with open(gt_path, "r") as gt_file:
        for line in gt_file:

            if '"' not in line and "'" in line:
                line = line.replace("'", '"')

            data = json.loads(line)

            # Only eval frames below num_frames_to_eval
            if int(data['id']) >= num_frames_to_eval:
                continue

            cam_sensor_name = data['sensorId']

            # Convert camera id to BEV sensor id
            bev_sensor_names = map_camera_name_to_bev_name[cam_sensor_name]
            for bev_sensor_name in bev_sensor_names:

                gt_sensors.add(bev_sensor_name)
                sensor_dir = os.path.join(output_base_dir, bev_sensor_name)
                os.makedirs(sensor_dir, exist_ok=True)
                gt_file_path = os.path.join(sensor_dir, "gt.json")

                if bev_sensor_name not in sensor_gt_writers:
                    sensor_gt_writers[bev_sensor_name] = open(gt_file_path, "w")

                sensor_gt_writers[bev_sensor_name].write(json.dumps(data) + "\n")

    # Close all GT writers
    for writer in sensor_gt_writers.values():
        writer.close()

    # Log found BEV sensors in GT
    logging.info(f"Found BEV sensors: {', '.join(sorted(gt_sensors))} in ground truth file.")

    # Create writers for Pred data
    sensor_pred_writers = {}
    with open(pred_path, "r") as pred_file:
        for line in pred_file:

            if '"' not in line and "'" in line:
                line = line.replace("'", '"')
            data = json.loads(line)

            # Only eval frames below num_frames_to_eval
            if int(data['id']) >= num_frames_to_eval:
                continue

            sensor_name = data['sensorId']
            pred_sensors.add(sensor_name)
            sensor_dir = os.path.join(output_base_dir, sensor_name)
            os.makedirs(sensor_dir, exist_ok=True)

            if sensor_name not in sensor_pred_writers:
                pred_file_path = os.path.join(sensor_dir, "pred.json")
                sensor_pred_writers[sensor_name] = open(pred_file_path, "w")

            filtered_objects = []
            for obj in data["objects"]:
                # Get the confidence value from bbox3d.
                confidence = obj["bbox3d"]["confidence"]
                if confidence >= confidence_threshold:
                    filtered_objects.append(obj)

            # Replace the "objects" list with the filtered version.
            data["objects"] = filtered_objects

            sensor_pred_writers[sensor_name].write(json.dumps(data) + "\n")

    # Close all Pred writers
    for writer in sensor_pred_writers.values():
        writer.close()

    # Log found BEV sensors in Prediction
    logging.info(f"Found BEV sensors: {', '.join(sorted(pred_sensors))} in prediction file.")
    print("")