vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/MatchAnything/imcui/hloc/pipelines/CMU/pipeline.py

@@ -0,0 +1,133 @@
+import argparse
+from pathlib import Path
+
+from ... import (
+    extract_features,
+    localize_sfm,
+    logger,
+    match_features,
+    pairs_from_covisibility,
+    pairs_from_retrieval,
+    triangulation,
+)
+
+TEST_SLICES = [2, 3, 4, 5, 6, 13, 14, 15, 16, 17, 18, 19, 20, 21]
+
+
+def generate_query_list(dataset, path, slice_):
+    cameras = {}
+    with open(dataset / "intrinsics.txt", "r") as f:
+        for line in f.readlines():
+            if line[0] == "#" or line == "\n":
+                continue
+            data = line.split()
+            cameras[data[0]] = data[1:]
+    assert len(cameras) == 2
+
+    queries = dataset / f"{slice_}/test-images-{slice_}.txt"
+    with open(queries, "r") as f:
+        queries = [q.rstrip("\n") for q in f.readlines()]
+
+    out = [[q] + cameras[q.split("_")[2]] for q in queries]
+    with open(path, "w") as f:
+        f.write("\n".join(map(" ".join, out)))
+
+
+def run_slice(slice_, root, outputs, num_covis, num_loc):
+    dataset = root / slice_
+    ref_images = dataset / "database"
+    query_images = dataset / "query"
+    sift_sfm = dataset / "sparse"
+
+    outputs = outputs / slice_
+    outputs.mkdir(exist_ok=True, parents=True)
+    query_list = dataset / "queries_with_intrinsics.txt"
+    sfm_pairs = outputs / f"pairs-db-covis{num_covis}.txt"
+    loc_pairs = outputs / f"pairs-query-netvlad{num_loc}.txt"
+    ref_sfm = outputs / "sfm_superpoint+superglue"
+    results = outputs / f"CMU_hloc_superpoint+superglue_netvlad{num_loc}.txt"
+
+    # pick one of the configurations for extraction and matching
+    retrieval_conf = extract_features.confs["netvlad"]
+    feature_conf = extract_features.confs["superpoint_aachen"]
+    matcher_conf = match_features.confs["superglue"]
+
+    pairs_from_covisibility.main(sift_sfm, sfm_pairs, num_matched=num_covis)
+    features = extract_features.main(feature_conf, ref_images, outputs, as_half=True)
+    sfm_matches = match_features.main(
+        matcher_conf, sfm_pairs, feature_conf["output"], outputs
+    )
+    triangulation.main(ref_sfm, sift_sfm, ref_images, sfm_pairs, features, sfm_matches)
+
+    generate_query_list(root, query_list, slice_)
+    global_descriptors = extract_features.main(retrieval_conf, ref_images, outputs)
+    global_descriptors = extract_features.main(retrieval_conf, query_images, outputs)
+    pairs_from_retrieval.main(
+        global_descriptors, loc_pairs, num_loc, query_list=query_list, db_model=ref_sfm
+    )
+
+    features = extract_features.main(feature_conf, query_images, outputs, as_half=True)
+    loc_matches = match_features.main(
+        matcher_conf, loc_pairs, feature_conf["output"], outputs
+    )
+
+    localize_sfm.main(
+        ref_sfm,
+        dataset / "queries/*_time_queries_with_intrinsics.txt",
+        loc_pairs,
+        features,
+        loc_matches,
+        results,
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--slices",
+        type=str,
+        default="*",
+        help="a single number, an interval (e.g. 2-6), "
+        "or a Python-style list or int (e.g. [2, 3, 4]",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=Path,
+        default="datasets/cmu_extended",
+        help="Path to the dataset, default: %(default)s",
+    )
+    parser.add_argument(
+        "--outputs",
+        type=Path,
+        default="outputs/aachen_extended",
+        help="Path to the output directory, default: %(default)s",
+    )
+    parser.add_argument(
+        "--num_covis",
+        type=int,
+        default=20,
+        help="Number of image pairs for SfM, default: %(default)s",
+    )
+    parser.add_argument(
+        "--num_loc",
+        type=int,
+        default=10,
+        help="Number of image pairs for loc, default: %(default)s",
+    )
+    args = parser.parse_args()
+
+    if args.slice == "*":
+        slices = TEST_SLICES
+    if "-" in args.slices:
+        min_, max_ = args.slices.split("-")
+        slices = list(range(int(min_), int(max_) + 1))
+    else:
+        slices = eval(args.slices)
+        if isinstance(slices, int):
+            slices = [slices]
+
+    for slice_ in slices:
+        logger.info("Working on slice %s.", slice_)
+        run_slice(
+            f"slice{slice_}", args.dataset, args.outputs, args.num_covis, args.num_loc
+        )

vismatch/third_party/MatchAnything/imcui/hloc/pipelines/Cambridge/pipeline.py

@@ -0,0 +1,140 @@
+import argparse
+from pathlib import Path
+
+from ... import (
+    extract_features,
+    localize_sfm,
+    logger,
+    match_features,
+    pairs_from_covisibility,
+    pairs_from_retrieval,
+    triangulation,
+)
+from .utils import create_query_list_with_intrinsics, evaluate, scale_sfm_images
+
+SCENES = ["KingsCollege", "OldHospital", "ShopFacade", "StMarysChurch", "GreatCourt"]
+
+
+def run_scene(images, gt_dir, outputs, results, num_covis, num_loc):
+    ref_sfm_sift = gt_dir / "model_train"
+    test_list = gt_dir / "list_query.txt"
+
+    outputs.mkdir(exist_ok=True, parents=True)
+    ref_sfm = outputs / "sfm_superpoint+superglue"
+    ref_sfm_scaled = outputs / "sfm_sift_scaled"
+    query_list = outputs / "query_list_with_intrinsics.txt"
+    sfm_pairs = outputs / f"pairs-db-covis{num_covis}.txt"
+    loc_pairs = outputs / f"pairs-query-netvlad{num_loc}.txt"
+
+    feature_conf = {
+        "output": "feats-superpoint-n4096-r1024",
+        "model": {
+            "name": "superpoint",
+            "nms_radius": 3,
+            "max_keypoints": 4096,
+        },
+        "preprocessing": {
+            "grayscale": True,
+            "resize_max": 1024,
+        },
+    }
+    matcher_conf = match_features.confs["superglue"]
+    retrieval_conf = extract_features.confs["netvlad"]
+
+    create_query_list_with_intrinsics(
+        gt_dir / "empty_all", query_list, test_list, ext=".txt", image_dir=images
+    )
+    with open(test_list, "r") as f:
+        query_seqs = {q.split("/")[0] for q in f.read().rstrip().split("\n")}
+
+    global_descriptors = extract_features.main(retrieval_conf, images, outputs)
+    pairs_from_retrieval.main(
+        global_descriptors,
+        loc_pairs,
+        num_loc,
+        db_model=ref_sfm_sift,
+        query_prefix=query_seqs,
+    )
+
+    features = extract_features.main(feature_conf, images, outputs, as_half=True)
+    pairs_from_covisibility.main(ref_sfm_sift, sfm_pairs, num_matched=num_covis)
+    sfm_matches = match_features.main(
+        matcher_conf, sfm_pairs, feature_conf["output"], outputs
+    )
+
+    scale_sfm_images(ref_sfm_sift, ref_sfm_scaled, images)
+    triangulation.main(
+        ref_sfm, ref_sfm_scaled, images, sfm_pairs, features, sfm_matches
+    )
+
+    loc_matches = match_features.main(
+        matcher_conf, loc_pairs, feature_conf["output"], outputs
+    )
+
+    localize_sfm.main(
+        ref_sfm,
+        query_list,
+        loc_pairs,
+        features,
+        loc_matches,
+        results,
+        covisibility_clustering=False,
+        prepend_camera_name=True,
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--scenes", default=SCENES, choices=SCENES, nargs="+")
+    parser.add_argument("--overwrite", action="store_true")
+    parser.add_argument(
+        "--dataset",
+        type=Path,
+        default="datasets/cambridge",
+        help="Path to the dataset, default: %(default)s",
+    )
+    parser.add_argument(
+        "--outputs",
+        type=Path,
+        default="outputs/cambridge",
+        help="Path to the output directory, default: %(default)s",
+    )
+    parser.add_argument(
+        "--num_covis",
+        type=int,
+        default=20,
+        help="Number of image pairs for SfM, default: %(default)s",
+    )
+    parser.add_argument(
+        "--num_loc",
+        type=int,
+        default=10,
+        help="Number of image pairs for loc, default: %(default)s",
+    )
+    args = parser.parse_args()
+
+    gt_dirs = args.dataset / "CambridgeLandmarks_Colmap_Retriangulated_1024px"
+
+    all_results = {}
+    for scene in args.scenes:
+        logger.info(f'Working on scene "{scene}".')
+        results = args.outputs / scene / "results.txt"
+        if args.overwrite or not results.exists():
+            run_scene(
+                args.dataset / scene,
+                gt_dirs / scene,
+                args.outputs / scene,
+                results,
+                args.num_covis,
+                args.num_loc,
+            )
+        all_results[scene] = results
+
+    for scene in args.scenes:
+        logger.info(f'Evaluate scene "{scene}".')
+        evaluate(
+            gt_dirs / scene / "empty_all",
+            all_results[scene],
+            gt_dirs / scene / "list_query.txt",
+            ext=".txt",
+        )

vismatch/third_party/MatchAnything/imcui/hloc/pipelines/Cambridge/utils.py

@@ -0,0 +1,145 @@
+import logging
+
+import cv2
+import numpy as np
+
+from hloc.utils.read_write_model import (
+    qvec2rotmat,
+    read_cameras_binary,
+    read_cameras_text,
+    read_images_binary,
+    read_images_text,
+    read_model,
+    write_model,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def scale_sfm_images(full_model, scaled_model, image_dir):
+    """Duplicate the provided model and scale the camera intrinsics so that
+    they match the original image resolution - makes everything easier.
+    """
+    logger.info("Scaling the COLMAP model to the original image size.")
+    scaled_model.mkdir(exist_ok=True)
+    cameras, images, points3D = read_model(full_model)
+
+    scaled_cameras = {}
+    for id_, image in images.items():
+        name = image.name
+        img = cv2.imread(str(image_dir / name))
+        assert img is not None, image_dir / name
+        h, w = img.shape[:2]
+
+        cam_id = image.camera_id
+        if cam_id in scaled_cameras:
+            assert scaled_cameras[cam_id].width == w
+            assert scaled_cameras[cam_id].height == h
+            continue
+
+        camera = cameras[cam_id]
+        assert camera.model == "SIMPLE_RADIAL"
+        sx = w / camera.width
+        sy = h / camera.height
+        assert sx == sy, (sx, sy)
+        scaled_cameras[cam_id] = camera._replace(
+            width=w, height=h, params=camera.params * np.array([sx, sx, sy, 1.0])
+        )
+
+    write_model(scaled_cameras, images, points3D, scaled_model)
+
+
+def create_query_list_with_intrinsics(
+    model, out, list_file=None, ext=".bin", image_dir=None
+):
+    """Create a list of query images with intrinsics from the colmap model."""
+    if ext == ".bin":
+        images = read_images_binary(model / "images.bin")
+        cameras = read_cameras_binary(model / "cameras.bin")
+    else:
+        images = read_images_text(model / "images.txt")
+        cameras = read_cameras_text(model / "cameras.txt")
+
+    name2id = {image.name: i for i, image in images.items()}
+    if list_file is None:
+        names = list(name2id)
+    else:
+        with open(list_file, "r") as f:
+            names = f.read().rstrip().split("\n")
+    data = []
+    for name in names:
+        image = images[name2id[name]]
+        camera = cameras[image.camera_id]
+        w, h, params = camera.width, camera.height, camera.params
+
+        if image_dir is not None:
+            # Check the original image size and rescale the camera intrinsics
+            img = cv2.imread(str(image_dir / name))
+            assert img is not None, image_dir / name
+            h_orig, w_orig = img.shape[:2]
+            assert camera.model == "SIMPLE_RADIAL"
+            sx = w_orig / w
+            sy = h_orig / h
+            assert sx == sy, (sx, sy)
+            w, h = w_orig, h_orig
+            params = params * np.array([sx, sx, sy, 1.0])
+
+        p = [name, camera.model, w, h] + params.tolist()
+        data.append(" ".join(map(str, p)))
+    with open(out, "w") as f:
+        f.write("\n".join(data))
+
+
+def evaluate(model, results, list_file=None, ext=".bin", only_localized=False):
+    predictions = {}
+    with open(results, "r") as f:
+        for data in f.read().rstrip().split("\n"):
+            data = data.split()
+            name = data[0]
+            q, t = np.split(np.array(data[1:], float), [4])
+            predictions[name] = (qvec2rotmat(q), t)
+    if ext == ".bin":
+        images = read_images_binary(model / "images.bin")
+    else:
+        images = read_images_text(model / "images.txt")
+    name2id = {image.name: i for i, image in images.items()}
+
+    if list_file is None:
+        test_names = list(name2id)
+    else:
+        with open(list_file, "r") as f:
+            test_names = f.read().rstrip().split("\n")
+
+    errors_t = []
+    errors_R = []
+    for name in test_names:
+        if name not in predictions:
+            if only_localized:
+                continue
+            e_t = np.inf
+            e_R = 180.0
+        else:
+            image = images[name2id[name]]
+            R_gt, t_gt = image.qvec2rotmat(), image.tvec
+            R, t = predictions[name]
+            e_t = np.linalg.norm(-R_gt.T @ t_gt + R.T @ t, axis=0)
+            cos = np.clip((np.trace(np.dot(R_gt.T, R)) - 1) / 2, -1.0, 1.0)
+            e_R = np.rad2deg(np.abs(np.arccos(cos)))
+        errors_t.append(e_t)
+        errors_R.append(e_R)
+
+    errors_t = np.array(errors_t)
+    errors_R = np.array(errors_R)
+
+    med_t = np.median(errors_t)
+    med_R = np.median(errors_R)
+    out = f"Results for file {results.name}:"
+    out += f"\nMedian errors: {med_t:.3f}m, {med_R:.3f}deg"
+
+    out += "\nPercentage of test images localized within:"
+    threshs_t = [0.01, 0.02, 0.03, 0.05, 0.25, 0.5, 5.0]
+    threshs_R = [1.0, 2.0, 3.0, 5.0, 2.0, 5.0, 10.0]
+    for th_t, th_R in zip(threshs_t, threshs_R):
+        ratio = np.mean((errors_t < th_t) & (errors_R < th_R))
+        out += f"\n\t{th_t*100:.0f}cm, {th_R:.0f}deg : {ratio*100:.2f}%"
+    logger.info(out)

vismatch/third_party/MatchAnything/imcui/hloc/pipelines/RobotCar/colmap_from_nvm.py

@@ -0,0 +1,176 @@
+import argparse
+import logging
+import sqlite3
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+from tqdm import tqdm
+
+from ...colmap_from_nvm import (
+    camera_center_to_translation,
+    recover_database_images_and_ids,
+)
+from ...utils.read_write_model import (
+    CAMERA_MODEL_IDS,
+    Camera,
+    Image,
+    Point3D,
+    write_model,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def read_nvm_model(nvm_path, database_path, image_ids, camera_ids, skip_points=False):
+    # Extract the intrinsics from the db file instead of the NVM model
+    db = sqlite3.connect(str(database_path))
+    ret = db.execute("SELECT camera_id, model, width, height, params FROM cameras;")
+    cameras = {}
+    for camera_id, camera_model, width, height, params in ret:
+        params = np.fromstring(params, dtype=np.double).reshape(-1)
+        camera_model = CAMERA_MODEL_IDS[camera_model]
+        assert len(params) == camera_model.num_params, (
+            len(params),
+            camera_model.num_params,
+        )
+        camera = Camera(
+            id=camera_id,
+            model=camera_model.model_name,
+            width=int(width),
+            height=int(height),
+            params=params,
+        )
+        cameras[camera_id] = camera
+
+    nvm_f = open(nvm_path, "r")
+    line = nvm_f.readline()
+    while line == "\n" or line.startswith("NVM_V3"):
+        line = nvm_f.readline()
+    num_images = int(line)
+    # assert num_images == len(cameras), (num_images, len(cameras))
+
+    logger.info(f"Reading {num_images} images...")
+    image_idx_to_db_image_id = []
+    image_data = []
+    i = 0
+    while i < num_images:
+        line = nvm_f.readline()
+        if line == "\n":
+            continue
+        data = line.strip("\n").lstrip("./").split(" ")
+        image_data.append(data)
+        image_idx_to_db_image_id.append(image_ids[data[0]])
+        i += 1
+
+    line = nvm_f.readline()
+    while line == "\n":
+        line = nvm_f.readline()
+    num_points = int(line)
+
+    if skip_points:
+        logger.info(f"Skipping {num_points} points.")
+        num_points = 0
+    else:
+        logger.info(f"Reading {num_points} points...")
+    points3D = {}
+    image_idx_to_keypoints = defaultdict(list)
+    i = 0
+    pbar = tqdm(total=num_points, unit="pts")
+    while i < num_points:
+        line = nvm_f.readline()
+        if line == "\n":
+            continue
+
+        data = line.strip("\n").split(" ")
+        x, y, z, r, g, b, num_observations = data[:7]
+        obs_image_ids, point2D_idxs = [], []
+        for j in range(int(num_observations)):
+            s = 7 + 4 * j
+            img_index, kp_index, kx, ky = data[s : s + 4]
+            image_idx_to_keypoints[int(img_index)].append(
+                (int(kp_index), float(kx), float(ky), i)
+            )
+            db_image_id = image_idx_to_db_image_id[int(img_index)]
+            obs_image_ids.append(db_image_id)
+            point2D_idxs.append(kp_index)
+
+        point = Point3D(
+            id=i,
+            xyz=np.array([x, y, z], float),
+            rgb=np.array([r, g, b], int),
+            error=1.0,  # fake
+            image_ids=np.array(obs_image_ids, int),
+            point2D_idxs=np.array(point2D_idxs, int),
+        )
+        points3D[i] = point
+
+        i += 1
+        pbar.update(1)
+    pbar.close()
+
+    logger.info("Parsing image data...")
+    images = {}
+    for i, data in enumerate(image_data):
+        # Skip the focal length. Skip the distortion and terminal 0.
+        name, _, qw, qx, qy, qz, cx, cy, cz, _, _ = data
+        qvec = np.array([qw, qx, qy, qz], float)
+        c = np.array([cx, cy, cz], float)
+        t = camera_center_to_translation(c, qvec)
+
+        if i in image_idx_to_keypoints:
+            # NVM only stores triangulated 2D keypoints: add dummy ones
+            keypoints = image_idx_to_keypoints[i]
+            point2D_idxs = np.array([d[0] for d in keypoints])
+            tri_xys = np.array([[x, y] for _, x, y, _ in keypoints])
+            tri_ids = np.array([i for _, _, _, i in keypoints])
+
+            num_2Dpoints = max(point2D_idxs) + 1
+            xys = np.zeros((num_2Dpoints, 2), float)
+            point3D_ids = np.full(num_2Dpoints, -1, int)
+            xys[point2D_idxs] = tri_xys
+            point3D_ids[point2D_idxs] = tri_ids
+        else:
+            xys = np.zeros((0, 2), float)
+            point3D_ids = np.full(0, -1, int)
+
+        image_id = image_ids[name]
+        image = Image(
+            id=image_id,
+            qvec=qvec,
+            tvec=t,
+            camera_id=camera_ids[name],
+            name=name.replace("png", "jpg"),  # some hack required for RobotCar
+            xys=xys,
+            point3D_ids=point3D_ids,
+        )
+        images[image_id] = image
+
+    return cameras, images, points3D
+
+
+def main(nvm, database, output, skip_points=False):
+    assert nvm.exists(), nvm
+    assert database.exists(), database
+
+    image_ids, camera_ids = recover_database_images_and_ids(database)
+
+    logger.info("Reading the NVM model...")
+    model = read_nvm_model(
+        nvm, database, image_ids, camera_ids, skip_points=skip_points
+    )
+
+    logger.info("Writing the COLMAP model...")
+    output.mkdir(exist_ok=True, parents=True)
+    write_model(*model, path=str(output), ext=".bin")
+    logger.info("Done.")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--nvm", required=True, type=Path)
+    parser.add_argument("--database", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    parser.add_argument("--skip_points", action="store_true")
+    args = parser.parse_args()
+    main(**args.__dict__)