convert_gt.py

from pathlib import Path
import os
from utils import load_json, write_json, dir_of_this_file, load_csv
import torch
# import numpy as np
from tqdm import tqdm


sn_2_imgdir = {
    e[0]: Path("/your_path/colmap_results/data/") / e[1]
    for e in load_csv(dir_of_this_file(__file__) / "seed_db.csv")
}


SAVE_ROOT = dir_of_this_file(__file__) / "gt_cams"


def write_cams(sn, all_cams):
    output_fn = SAVE_ROOT / f"{sn}.json"
    write_json(output_fn, all_cams)
    print(sn, end=',')
    print(output_fn)


def list_scene_fnames(sn):
    return list(sorted(os.listdir(sn_2_imgdir[sn])))


def break_scenes(raw):
    raw = raw.strip().split('\n')
    return [e.strip() for e in raw]


def strip_sn_prefix(sn_name):
    parts = sn_name.split("_")[1:]
    return "_".join(parts)


def invert_trans(trans_T):
    assert trans_T.shape == (4, 4)
    R = trans_T[0:3, 0:3]
    t = trans_T[0:3, 3:4]
    new_T = torch.eye(4, dtype=trans_T.dtype, device=trans_T.device)
    new_T[0:3, 0:3] = R.T
    new_T[0:3, 3:4] = -R.T @ t
    return new_T


def hike():
    ''' # these are problematic scenes
    hike_garden2: cams without their images!
    '''

    scenes = '''
    hike_forest1
    hike_forest2
    hike_forest3
    hike_garden3
    hike_indoor
    hike_playground
    hike_university1
    hike_university2
    hike_university3
    hike_university4
    '''
    scenes = break_scenes(scenes)
    root = Path("/your_path/colmap_results/data/statichike")

    # for sn in scenes:
    #     gt_path = f"/your_path/colmap_results/data/statichike/{strip_sn_prefix(sn)}/sparse"
    #     gt_path = Path(gt_path)
    #     assert not (gt_path / "1").is_dir()
    #     print(sn, end=',')
    #     print(str(gt_path / "0"))
    # return

    for sn in scenes:
        img_fnames = list_scene_fnames(sn)

        raw = load_json(
            root / strip_sn_prefix(sn) / "transforms.json"
        )
        frames = list(sorted(raw['frames'], key=lambda x: x['file_path']))

        cam_dir = root / strip_sn_prefix(sn) / "sparse"
        assert not (cam_dir / "1").is_dir()

        fr_fnames = [Path(fr['file_path']).name for fr in frames]

        c2ws_b = torch.tensor(
            [fr['transform_matrix'] for fr in frames],
            dtype=torch.float64, device="cuda"
        )
        # from opengl to opencv
        c2ws_b[:, :, 1] *= -1
        c2ws_b[:, :, 2] *= -1

        try:
            from metrics import load_colmap_db_cams, pose_stats_suite
            # from read_colmap_model import read_colmap_w2c
            # names, intrs, Rs, ts = read_colmap_w2c(cam_dir / "0")
            names, _, c2ws_a = load_colmap_db_cams(cam_dir / "0", ".bin", return_all=True)
            assert fr_fnames == names
            res = pose_stats_suite(c2ws_a, c2ws_b)
            assert res['ate'] < 1e-5
            assert res['auc_p'][0] > 99.99
            del names, c2ws_a, res
            '''
            the c2w in frames are globally shifted for some reason.
            check that after alignment, error is small.
            '''
        except FileNotFoundError as e:
            print(e)

        # some imgs are discarded in gt cams
        assert set(fr_fnames).issubset(set(img_fnames))
        # if len(fr_fnames) != len(img_fnames):
        #     print(f"{sn} img {len(img_fnames)} vs cam {len(fr_fnames)}")

        c2ws_b = c2ws_b.cpu().float().tolist()
        all_cams = []
        for i in range(len(frames)):
            all_cams.append({
                'fname': fr_fnames[i],
                'c2w': c2ws_b[i]
            })

        write_cams(sn, all_cams)


def process_meganerf_cam(cam):
    c2w = cam['c2w']  # [3, 4] opengl: x-right, y-up, z-back
    x, y, z, t = torch.unbind(c2w, dim=1)
    c2w = torch.stack([x, -y, -z, t], dim=-1)  # opengl -> opencv
    full_c2w = torch.eye(4)
    full_c2w[0:3] = c2w
    return full_c2w


def mill19():
    scenes = """
    mill19_building
    mill19_rubble
    """
    scenes = break_scenes(scenes)

    for sn in scenes:
        img_fnames = list_scene_fnames(sn)
        cam_dir = Path(f"/your_path/colmap_results/data/mill19/{strip_sn_prefix(sn)}-pixsfm/train/metadata")
        all_cams = []
        for im in tqdm(img_fnames):
            cam_file = cam_dir / Path(im).with_suffix(".pt")
            assert cam_file.is_file()
            cam = torch.load(cam_file, weights_only=True)
            c2w = process_meganerf_cam(cam)
            all_cams.append({
                'fname': im,
                'c2w': c2w.tolist()
            })

        write_cams(sn, all_cams)


def urban_scene():
    from string import Template

    scenes = '''
    urbn_Campus
    urbn_Residence
    urbn_Sci-Art
    '''
    scenes = break_scenes(scenes)
    for sn in scenes:
        _sn = strip_sn_prefix(sn).lower()
        lns = load_csv(
            f"/your_path/colmap_results/data/urbanscene3d_meganerf/{_sn}-pixsfm/mappings.txt"
        )
        cam_dir_template = Template(
            "/your_path/colmap_results/data/urbanscene3d_meganerf/${sn}-pixsfm/${split}/metadata"
        )

        im_2_camfn = {e[0]: e[1] for e in lns}
        all_cams = []
        keys = list(sorted(im_2_camfn.keys()))
        for k in tqdm(keys):
            # default assumes it's under train/
            camfn = Path(cam_dir_template.substitute(sn=_sn, split="train")) / im_2_camfn[k]
            if not camfn.is_file():
                camfn = Path(cam_dir_template.substitute(sn=_sn, split="val")) / im_2_camfn[k]
                assert camfn.is_file()

            cam = torch.load(camfn, weights_only=True)
            c2w = process_meganerf_cam(cam)
            all_cams.append({
                'fname': k,
                'c2w': c2w.tolist()
            })

        write_cams(sn, all_cams)


def nerf_osr():
    scenes = """
    nosr_europa
    nosr_lk2
    nosr_lwp
    nosr_rathaus
    nosr_schloss
    nosr_st
    nosr_stjacob
    nosr_stjohann
    """
    scenes = break_scenes(scenes)

    for sn in scenes:
        img_fnames = list_scene_fnames(sn)
        raw = load_json(
            f"/your_path/colmap_results/data/nerfosr_original/{strip_sn_prefix(sn)}/final/kai_cameras.json"
        )
        all_cams = []
        for im in img_fnames:
            cam = raw[im]
            w2c = torch.tensor(cam['W2C'], dtype=torch.float64).reshape(4, 4)
            c2w = invert_trans(w2c)
            all_cams.append({
                'fname': im,
                'c2w': c2w.tolist()
            })

        write_cams(sn, all_cams)


def drone_deploy():
    # ruin1 has missing images. ignore that scene
    scenes = """
    dploy_house1
    dploy_house2
    dploy_house3
    dploy_house4
    dploy_pipes1
    dploy_ruins1
    dploy_ruins2
    dploy_ruins3
    dploy_tower1
    dploy_tower2
    """
    scenes = break_scenes(scenes)
    for sn in scenes:
        img_fnames = list_scene_fnames(sn)
        raw = load_json(
            f"/your_path/colmap_results/data/dronedeploy/{strip_sn_prefix(sn)}/cameras.json"
        )
        # keys: 'frames', 'fl_x', 'fl_y', 'k1', 'k2', 'p1', 'p2', 'k3', 'k4', 'k5', 'k6', 'cx', 'cy', 'w', 'h',
        #       'camera_angle_x', 'camera_angle_y', 'aabb_scale'
        frames = raw['frames']
        frames = list(sorted(frames, key=lambda x: x['file_path']))

        # print(f"{sn}, {len(img_fnames)} vs {len(frames)}")
        _fnames = [
            Path(e['file_path']).name
            for e in frames
        ]

        has_missing_img = False
        for e in _fnames:
            if e not in img_fnames:
                has_missing_img = True
                # print(f"warn! img for {e} missing")

        if has_missing_img:
            # ruin1 has missing images. ignore that scene
            continue

        # some imgs don't have gt cam
        # assert img_fnames == _fnames

        all_cams = []
        for fr in frames:
            c2w = torch.tensor(fr['transform_matrix'])
            x, y, z, t = torch.unbind(c2w, dim=1)
            c2w = torch.stack([x, -y, -z, t], dim=-1)  # opengl -> opencv
            all_cams.append({
                'fname': Path(fr['file_path']).name,
                'c2w': c2w.tolist()
            })

        write_cams(sn, all_cams)


def mipnerf360():
    scenes = """
    m360_flowers
    m360_room
    m360_counter
    m360_stump
    m360_kitchen
    m360_garden
    m360_bicycle
    m360_bonsai
    m360_treehill
    """
    scenes = break_scenes(scenes)
    for sn in scenes:
        path = f"/your_path/nerfbln_dset/mipnerf360/{strip_sn_prefix(sn)}/sparse/0"
        print(sn, end=',')
        print(path)


def eyeful():
    scenes = """
    eft_apartment
    eft_kitchen
    """

    # def make_filter_f(sensor_prefix):
    #     return lambda fr: fr['cameraId'].split('/')[0] != sensor_prefix

    scenes = break_scenes(scenes)
    for sn in scenes:
        frames = load_json(
            Path(f"/your_path/colmap_results/data/eyefultower/{strip_sn_prefix(sn)}/cameras.json")
        )['KRT']
        frames = sorted(frames, key=lambda x: x['cameraId'])

        # # filter low overlap cameras
        # prefix_to_discard = {
        #     'eft_apartment': '31',
        #     'eft_kitchen': '28'
        # }[sn]
        # n_before = len(frames)
        # frames = list(filter(make_filter_f(prefix_to_discard), frames))
        # n_after = len(frames)
        # print(f"{n_before} vs {n_after}")

        all_cams = []
        for fr in tqdm(frames):
            w2c = torch.tensor(fr['T']).T  # note the transpose. col_major -> row major
            c2w = invert_trans(w2c)
            all_cams.append({
                'fname': f"{fr['cameraId']}.jpg",
                'c2w': c2w.tolist()
            })

        write_cams(sn, all_cams)

    # I renamed the gt jsons that discarded low overlap cams as
    #   eft_apartment_remove_31.json
    #   eft_kitchen_remove_28.json
    # they are created on 25.03.10 14:54
    # the other gt files are made from 25.02.23 - 23.02.26


def tnt():
    scenes = '''
    tnt_advn_Auditorium
    tnt_advn_Ballroom
    tnt_advn_Courtroom
    tnt_advn_Museum
    tnt_advn_Palace
    tnt_advn_Temple
    tnt_intrmdt_Family
    tnt_intrmdt_Francis
    tnt_intrmdt_Horse
    tnt_intrmdt_Lighthouse
    tnt_intrmdt_M60
    tnt_intrmdt_Panther
    tnt_intrmdt_Playground
    tnt_intrmdt_Train
    tnt_trng_Barn
    tnt_trng_Caterpillar
    tnt_trng_Church
    tnt_trng_Courthouse
    tnt_trng_Ignatius
    tnt_trng_Meetingroom
    tnt_trng_Truck
    '''
    scenes = break_scenes(scenes)
    for sn in scenes:
        _sn = sn.split('_')[-1].lower()
        gt_cam_path = f"/your_path/nerfbln_dset/tnt/{_sn}/sparse"  # no 0/
        print(sn, end=',')
        print(gt_cam_path)


def eth3d_dslr():
    scenes = '''
    eth3d_dslr_botanical_garden
    eth3d_dslr_boulders
    eth3d_dslr_bridge
    eth3d_dslr_courtyard
    eth3d_dslr_delivery_area
    eth3d_dslr_door
    eth3d_dslr_electro
    eth3d_dslr_exhibition_hall
    eth3d_dslr_facade
    eth3d_dslr_kicker
    eth3d_dslr_lecture_room
    eth3d_dslr_living_room
    eth3d_dslr_lounge
    eth3d_dslr_meadow
    eth3d_dslr_observatory
    eth3d_dslr_office
    eth3d_dslr_old_computer
    eth3d_dslr_pipes
    eth3d_dslr_playground
    eth3d_dslr_relief
    eth3d_dslr_relief_2
    eth3d_dslr_statue
    eth3d_dslr_terrace
    eth3d_dslr_terrace_2
    eth3d_dslr_terrains
    '''
    scenes = break_scenes(scenes)

    # # used to edit db_mapping.csv
    # for sn in scenes:
    #     db_path = f"/your_path/sfm_workspace/runs_db/d_{sn}/database.db"
    #     assert Path(db_path).is_file()
    #     print(sn, end=',')
    #     print(db_path)
    # return

    for sn in scenes:
        _sn = sn[len('eth3d_dslr_'):]
        gt_cam_path = f"/your_path/colmap_results/data/eth3d_dslr/{_sn}/dslr_calibration_undistorted"
        assert Path(gt_cam_path).is_dir()
        print(sn, end=',')
        print(gt_cam_path)


def main():
    # hike()
    # mill19()
    # nerf_osr()
    # mipnerf360()
    # eyeful()
    # tnt()
    # urban_scene()
    # drone_deploy()
    # eth3d_dslr()
    pass


if __name__ == "__main__":
    main()