skill_saveplace/code/HOTFLoc/dataset/CSWildPlaces/postprocess_submaps.py

"""
Post-processing for CSWildPlaces submaps. Allows for downsampling,
normalisation, and removing ground points.

TODO List:
    - Disable CSF console output (low prio)

By Ethan Griffiths (Data61, CSIRO)
"""
from os import path, makedirs, listdir
import argparse
import glob
from datetime import datetime
from time import sleep

import numpy as np
import pandas as pd
import open3d as o3d

from dataset.CSWildPlaces.processing_utils import random_down_sample, pnvlad_down_sample, voxel_down_sample, \
    normalise_pcl, remove_ground_CSF, make_o3d_pcl, multiprocessing_func, \
    CLOUD_SAVE_DIR, POSES_FILENAME

RANDOM_SEED = 42
SAVE_FOLDER_BASE = 'postproc'

def save_info(root: str, save_dir: str):
    """
    Save txt file with info of what post-processing was done to what data.
    """
    txt_file = path.join(save_dir, 'postproc_info.txt')
    with open(txt_file, 'w') as f:
        now = datetime.now()
        f.write(f'Created: {now.strftime("%Y/%m/%d-%H:%M:%S")}\n\n')
        f.write(f'Root folder: {path.abspath(root)}\n')
        f.write('Args:\n')
        f.write(str(args))
    return True

def postprocess_submap(submap: str):
    """
    Post-process an individual submap. Order is: ground removal -> downsampling 
    -> normalisation.
    """
    timestamp = path.splitext(path.split(submap)[1])[0]
    if args.debug:
        print(timestamp)
    cloud = o3d.io.read_point_cloud(submap)
    pts = np.asarray(cloud.points)
    if args.remove_ground:
        pts = remove_ground_CSF(pts, args.debug)
    num_pts = len(pts)
    pts_final = pts    
    if len(pts_final) < args.min_num_points:    # too few points (probably CSF's fault)
        return timestamp
    if args.downsample:
        if args.downsample_type != 'voxel' and num_pts < args.downsample_target:    # too few points after CSF
            return timestamp
        if args.downsample_type == 'random':
            pts_downsampled = random_down_sample(
                pts, args.downsample_target, RANDOM_SEED
            )
        elif args.downsample_type == 'voxel':
            pts_downsampled = voxel_down_sample(
                pts, args.voxel_size
            )
        elif args.downsample_type == 'pnvlad':
            pts_downsampled = pnvlad_down_sample(
                pts, args.downsample_target, RANDOM_SEED
            )
        else:
            raise(ValueError("Downsample type not recognised"))
        num_pts_downsampled = len(pts_downsampled)
        assert (
            args.downsample_type == 'voxel' or \
            num_pts_downsampled == args.downsample_target
        ),  f'Cloud has {num_pts_downsampled} points after downsampling'
        pts_final = pts_downsampled
    if args.normalise:
        pts_final = normalise_pcl(
            pts_final, pts, args.downsample_target, RANDOM_SEED
        )
    if len(pts_final) < args.min_num_points:    # too few points (probably CSF's fault)
        return timestamp
    cloud_final = make_o3d_pcl(pts_final)
    o3d.io.write_point_cloud(   # Save downsampled cloud
        path.join(SAVE_DIR, path.relpath(submap, args.root)), cloud_final
    )
    
    return None

def postprocessing():
    global SAVE_DIR
    SAVE_DIR = args.save_dir
    if SAVE_DIR is None:
        save_folder = SAVE_FOLDER_BASE
        if args.downsample:
            downsample_str = 'rand' if args.downsample_type == 'random' else args.downsample_type
            if args.downsample_type == 'voxel':
                save_folder += f'_{downsample_str}_ds_{args.voxel_size:0.2f}m'
            else:
                save_folder += f'_{downsample_str}_ds_{args.downsample_target}'
        if args.remove_ground:
            save_folder += '_rmground'
        if args.normalise:
            save_folder += '_normalised'
        SAVE_DIR = path.join(args.root, f'../{save_folder}/')
    
    if path.exists(SAVE_DIR):
        print(f"[WARNING] Save directory '{SAVE_DIR}' already exists. Overwriting in 5 seconds...")
        sleep(5)
    else:
        makedirs(SAVE_DIR)
    
    _ = save_info(args.root, SAVE_DIR)
    
    # Iterate through each split
    splits = args.splits
    if splits == []:
        splits = sorted(listdir(args.root))
    
    assert len(splits) > 0, 'Invalid root dir, no splits found'

    for split in splits:
        split_path = path.join(args.root, split)
        if not path.isdir(split_path):
            continue
        
        for folder in sorted(glob.glob(f'{split_path}/*/')):
            if any([dir in folder for dir in args.exclude_dirs]):
                print(f"Skipping '{folder}'")
                continue
            folder_relpath = path.relpath(folder, args.root)
            folder_save_dir = path.join(SAVE_DIR, folder_relpath, CLOUD_SAVE_DIR)
            poses_save_path = path.join(SAVE_DIR, folder_relpath, POSES_FILENAME)
            if not path.exists(folder_save_dir):
                makedirs(folder_save_dir)
            
            # Multiprocessing
            print(f"Processing '{folder}'")
            inputs = glob.glob(f'{folder}/**/*.pcd')
            results = multiprocessing_func(
                postprocess_submap, inputs, num_workers=args.num_workers
            )
            failed_submaps = [x for x in results if x is not None]
            
            # Copy poses
            poses_path = path.join(folder, POSES_FILENAME)
            poses = pd.read_csv(poses_path, dtype={'timestamp':str})
            # filter out removed submaps
            if len(failed_submaps) > 0:
                print(f"Dropped: {len(failed_submaps)} submaps")
                poses = poses[~poses.timestamp.str.contains('|'.join(failed_submaps))]
            assert len(poses) == len(listdir(folder_save_dir)), \
                "# of entries in poses file and # saved submaps do not match up"
            poses.to_csv(poses_save_path, index=False)
    
    return True


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--root', type = str, required = True, 
                        help='Root directory containing split folders of CSWildPlaces dataset')
    parser.add_argument('--save_dir', type = str, default = None, 
                        help='Directory to save downsampled splits to, default is the parent directory of --root')
    parser.add_argument('--remove_ground', action = 'store_true', 
                        help='Remove ground points using CSF')
    parser.add_argument('--min_num_points', type = int, default = 4096,
                        help='Minimum number of points to consider as a valid submap. Useful after ground removal, incase the submap was nearly entirely flat.')
    parser.add_argument('--downsample', action = 'store_true', 
                        help='Dowsample point cloud')
    parser.add_argument('--downsample_target', type = int, default = 4096,
                        help='Number of points to downsample to')
    parser.add_argument('--downsample_type', type = str, default = 'voxel', choices = ['pnvlad', 'random', 'voxel'],
                        help='Downsampling method')
    parser.add_argument('--voxel_size', type = float, default = 0.8,
                        help='Voxel size (m), if using voxel downsampling')
    parser.add_argument('--normalise', action = 'store_true', 
                        help='Use PNVLAD normalisation to [-1, 1] range')
    parser.add_argument('--num_workers', type = int, default = 1, 
                        help='Enable multiprocessing, specifying number of workers')
    parser.add_argument('--splits', nargs = '+', default = [], 
                        help='Splits (min 1) in root folder to process. Processes every folder in root if empty.')
    parser.add_argument('--exclude_dirs', nargs = '+', default = [], 
                        help='List of dirs to ignore during preprocessing')
    parser.add_argument('--debug', action='store_true',
                        help='Enable debugging messages and visualisations')
    args = parser.parse_args()
    print(args)
    assert (args.remove_ground or args.downsample or args.normalise), \
        "Select a post-processing option, otherwise nothing is being done!"
    if not args.downsample or args.downsample_type == 'voxel':
        args.downsample_target = None
    else:
        assert args.downsample_target >= args.min_num_points, \
            "Cannot downsample to less than minimum allowed point count."
    
    postprocessing()