vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/MatchFormer/model/utils/metrics.py

@@ -0,0 +1,193 @@
+import torch
+import cv2
+import numpy as np
+from collections import OrderedDict
+from loguru import logger
+from kornia.geometry.epipolar import numeric
+from kornia.geometry.conversions import convert_points_to_homogeneous
+
+
+# --- METRICS ---
+
+def relative_pose_error(T_0to1, R, t, ignore_gt_t_thr=0.0):
+    # angle error between 2 vectors
+    t_gt = T_0to1[:3, 3]
+    n = np.linalg.norm(t) * np.linalg.norm(t_gt)
+    t_err = np.rad2deg(np.arccos(np.clip(np.dot(t, t_gt) / n, -1.0, 1.0)))
+    t_err = np.minimum(t_err, 180 - t_err)  # handle E ambiguity
+    if np.linalg.norm(t_gt) < ignore_gt_t_thr:  # pure rotation is challenging
+        t_err = 0
+
+    # angle error between 2 rotation matrices
+    R_gt = T_0to1[:3, :3]
+    cos = (np.trace(np.dot(R.T, R_gt)) - 1) / 2
+    cos = np.clip(cos, -1., 1.)  # handle numercial errors
+    R_err = np.rad2deg(np.abs(np.arccos(cos)))
+
+    return t_err, R_err
+
+
+def symmetric_epipolar_distance(pts0, pts1, E, K0, K1):
+    """Squared symmetric epipolar distance.
+    This can be seen as a biased estimation of the reprojection error.
+    Args:
+        pts0 (torch.Tensor): [N, 2]
+        E (torch.Tensor): [3, 3]
+    """
+    pts0 = (pts0 - K0[[0, 1], [2, 2]][None]) / K0[[0, 1], [0, 1]][None]
+    pts1 = (pts1 - K1[[0, 1], [2, 2]][None]) / K1[[0, 1], [0, 1]][None]
+    pts0 = convert_points_to_homogeneous(pts0)
+    pts1 = convert_points_to_homogeneous(pts1)
+
+    Ep0 = pts0 @ E.T  # [N, 3]
+    p1Ep0 = torch.sum(pts1 * Ep0, -1)  # [N,]
+    Etp1 = pts1 @ E  # [N, 3]
+
+    d = p1Ep0**2 * (1.0 / (Ep0[:, 0]**2 + Ep0[:, 1]**2) + 1.0 / (Etp1[:, 0]**2 + Etp1[:, 1]**2))  # N
+    return d
+
+
+def compute_symmetrical_epipolar_errors(data):
+    """ 
+    Update:
+        data (dict):{"epi_errs": [M]}
+    """
+    Tx = numeric.cross_product_matrix(data['T_0to1'][:, :3, 3])
+    E_mat = Tx @ data['T_0to1'][:, :3, :3]
+
+    m_bids = data['m_bids']
+    pts0 = data['mkpts0_f']
+    pts1 = data['mkpts1_f']
+
+    epi_errs = []
+    for bs in range(Tx.size(0)):
+        mask = m_bids == bs
+        epi_errs.append(
+            symmetric_epipolar_distance(pts0[mask], pts1[mask], E_mat[bs], data['K0'][bs], data['K1'][bs]))
+    epi_errs = torch.cat(epi_errs, dim=0)
+
+    data.update({'epi_errs': epi_errs})
+
+
+def estimate_pose(kpts0, kpts1, K0, K1, thresh, conf=0.99999):
+    if len(kpts0) < 5:
+        return None
+    # normalize keypoints
+    kpts0 = (kpts0 - K0[[0, 1], [2, 2]][None]) / K0[[0, 1], [0, 1]][None]
+    kpts1 = (kpts1 - K1[[0, 1], [2, 2]][None]) / K1[[0, 1], [0, 1]][None]
+
+    # normalize ransac threshold
+    ransac_thr = thresh / np.mean([K0[0, 0], K1[1, 1], K0[0, 0], K1[1, 1]])
+
+    # compute pose with cv2
+    E, mask = cv2.findEssentialMat(
+        kpts0, kpts1, np.eye(3), threshold=ransac_thr, prob=conf, method=cv2.RANSAC)
+    if E is None:
+        print("\nE is None while trying to recover pose.\n")
+        return None
+
+    # recover pose from E
+    best_num_inliers = 0
+    ret = None
+    for _E in np.split(E, len(E) / 3):
+        n, R, t, _ = cv2.recoverPose(_E, kpts0, kpts1, np.eye(3), 1e9, mask=mask)
+        if n > best_num_inliers:
+            ret = (R, t[:, 0], mask.ravel() > 0)
+            best_num_inliers = n
+
+    return ret
+
+
+def compute_pose_errors(data, config):
+    """ 
+    Update:
+        data (dict):{
+            "R_errs" List[float]: [N]
+            "t_errs" List[float]: [N]
+            "inliers" List[np.ndarray]: [N]
+        }
+    """
+    pixel_thr = config.TRAINER.RANSAC_PIXEL_THR  # 0.5
+    conf = config.TRAINER.RANSAC_CONF  # 0.99999
+    data.update({'R_errs': [], 't_errs': [], 'inliers': []})
+
+    m_bids = data['m_bids'].cpu().numpy()
+    pts0 = data['mkpts0_f'].cpu().numpy()
+    pts1 = data['mkpts1_f'].cpu().numpy()
+    K0 = data['K0'].cpu().numpy()
+    K1 = data['K1'].cpu().numpy()
+    T_0to1 = data['T_0to1'].cpu().numpy()
+
+    for bs in range(K0.shape[0]):
+        mask = m_bids == bs
+        ret = estimate_pose(pts0[mask], pts1[mask], K0[bs], K1[bs], pixel_thr, conf=conf)
+
+        if ret is None:
+            data['R_errs'].append(np.inf)
+            data['t_errs'].append(np.inf)
+            data['inliers'].append(np.array([]).astype(np.bool))
+        else:
+            R, t, inliers = ret
+            t_err, R_err = relative_pose_error(T_0to1[bs], R, t, ignore_gt_t_thr=0.0)
+            data['R_errs'].append(R_err)
+            data['t_errs'].append(t_err)
+            data['inliers'].append(inliers)
+
+
+# --- METRIC AGGREGATION ---
+
+def error_auc(errors, thresholds):
+    """
+    Args:
+        errors (list): [N,]
+        thresholds (list)
+    """
+    errors = [0] + sorted(list(errors))
+    recall = list(np.linspace(0, 1, len(errors)))
+
+    aucs = []
+    thresholds = [5, 10, 20]
+    for thr in thresholds:
+        last_index = np.searchsorted(errors, thr)
+        y = recall[:last_index] + [recall[last_index-1]]
+        x = errors[:last_index] + [thr]
+        aucs.append(np.trapz(y, x) / thr)
+
+    return {f'auc@{t}': auc for t, auc in zip(thresholds, aucs)}
+
+
+def epidist_prec(errors, thresholds, ret_dict=False):
+    precs = []
+    for thr in thresholds:
+        prec_ = []
+        for errs in errors:
+            correct_mask = errs < thr
+            prec_.append(np.mean(correct_mask) if len(correct_mask) > 0 else 0)
+        precs.append(np.mean(prec_) if len(prec_) > 0 else 0)
+    if ret_dict:
+        return {f'prec@{t:.0e}': prec for t, prec in zip(thresholds, precs)}
+    else:
+        return precs
+
+
+def aggregate_metrics(metrics, epi_err_thr=5e-4):
+    """ Aggregate metrics for the whole dataset:
+    (This method should be called once per dataset)
+    1. AUC of the pose error (angular) at the threshold [5, 10, 20]
+    2. Mean matching precision at the threshold 5e-4(ScanNet), 1e-4(MegaDepth)
+    """
+    # filter duplicates
+    unq_ids = OrderedDict((iden, id) for id, iden in enumerate(metrics['identifiers']))
+    unq_ids = list(unq_ids.values())
+    logger.info(f'Aggregating metrics over {len(unq_ids)} unique items...')
+
+    # pose auc
+    angular_thresholds = [5, 10, 20]
+    pose_errors = np.max(np.stack([metrics['R_errs'], metrics['t_errs']]), axis=0)[unq_ids]
+    aucs = error_auc(pose_errors, angular_thresholds)  # (auc@5, auc@10, auc@20)
+
+    # matching precision
+    dist_thresholds = [epi_err_thr]
+    precs = epidist_prec(np.array(metrics['epi_errs'], dtype=object)[unq_ids], dist_thresholds, True)  # (prec@err_thr)
+
+    return {**aucs, **precs}

vismatch/third_party/MatchFormer/model/utils/misc.py

@@ -0,0 +1,101 @@
+import os
+import contextlib
+import joblib
+from typing import Union
+from loguru import _Logger, logger
+from itertools import chain
+
+import torch
+from yacs.config import CfgNode as CN
+from pytorch_lightning.utilities import rank_zero_only
+
+
+def lower_config(yacs_cfg):
+    if not isinstance(yacs_cfg, CN):
+        return yacs_cfg
+    return {k.lower(): lower_config(v) for k, v in yacs_cfg.items()}
+
+
+def upper_config(dict_cfg):
+    if not isinstance(dict_cfg, dict):
+        return dict_cfg
+    return {k.upper(): upper_config(v) for k, v in dict_cfg.items()}
+
+
+def log_on(condition, message, level):
+    if condition:
+        assert level in ['INFO', 'DEBUG', 'WARNING', 'ERROR', 'CRITICAL']
+        logger.log(level, message)
+
+
+def get_rank_zero_only_logger(logger: _Logger):
+    if rank_zero_only.rank == 0:
+        return logger
+    else:
+        for _level in logger._core.levels.keys():
+            level = _level.lower()
+            setattr(logger, level,
+                    lambda x: None)
+        logger._log = lambda x: None
+    return logger
+
+
+def setup_gpus(gpus: Union[str, int]) -> int:
+    """ A temporary fix for pytorch-lighting 1.3.x """
+    gpus = str(gpus)
+    gpu_ids = []
+    
+    if ',' not in gpus:
+        n_gpus = int(gpus)
+        return n_gpus if n_gpus != -1 else torch.cuda.device_count()
+    else:
+        gpu_ids = [i.strip() for i in gpus.split(',') if i != '']
+    
+    # setup environment variables
+    visible_devices = os.getenv('CUDA_VISIBLE_DEVICES')
+    if visible_devices is None:
+        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+        os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(str(i) for i in gpu_ids)
+        visible_devices = os.getenv('CUDA_VISIBLE_DEVICES')
+        logger.warning(f'[Temporary Fix] manually set CUDA_VISIBLE_DEVICES when specifying gpus to use: {visible_devices}')
+    else:
+        logger.warning('[Temporary Fix] CUDA_VISIBLE_DEVICES already set by user or the main process.')
+    return len(gpu_ids)
+
+
+def flattenList(x):
+    return list(chain(*x))
+
+
+@contextlib.contextmanager
+def tqdm_joblib(tqdm_object):
+    """Context manager to patch joblib to report into tqdm progress bar given as argument
+    
+    Usage:
+        with tqdm_joblib(tqdm(desc="My calculation", total=10)) as progress_bar:
+            Parallel(n_jobs=16)(delayed(sqrt)(i**2) for i in range(10))
+            
+    When iterating over a generator, directly use of tqdm is also a solutin (but monitor the task queuing, instead of finishing)
+        ret_vals = Parallel(n_jobs=args.world_size)(
+                    delayed(lambda x: _compute_cov_score(pid, *x))(param)
+                        for param in tqdm(combinations(image_ids, 2),
+                                          desc=f'Computing cov_score of [{pid}]',
+                                          total=len(image_ids)*(len(image_ids)-1)/2))
+    Src: https://stackoverflow.com/a/58936697
+    """
+    class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        def __call__(self, *args, **kwargs):
+            tqdm_object.update(n=self.batch_size)
+            return super().__call__(*args, **kwargs)
+
+    old_batch_callback = joblib.parallel.BatchCompletionCallBack
+    joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback
+    try:
+        yield tqdm_object
+    finally:
+        joblib.parallel.BatchCompletionCallBack = old_batch_callback
+        tqdm_object.close()
+

vismatch/third_party/MatchFormer/model/utils/profiler.py

@@ -0,0 +1,39 @@
+import torch
+from pytorch_lightning.profiler import SimpleProfiler, PassThroughProfiler
+from contextlib import contextmanager
+from pytorch_lightning.utilities import rank_zero_only
+
+
+class InferenceProfiler(SimpleProfiler):
+    """
+    This profiler records duration of actions with cuda.synchronize()
+    Use this in test time. 
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.start = rank_zero_only(self.start)
+        self.stop = rank_zero_only(self.stop)
+        self.summary = rank_zero_only(self.summary)
+
+    @contextmanager
+    def profile(self, action_name: str) -> None:
+        try:
+            torch.cuda.synchronize()
+            self.start(action_name)
+            yield action_name
+        finally:
+            torch.cuda.synchronize()
+            self.stop(action_name)
+
+
+def build_profiler(name):
+    if name == 'inference':
+        return InferenceProfiler()
+    elif name == 'pytorch':
+        from pytorch_lightning.profiler import PyTorchProfiler
+        return PyTorchProfiler(use_cuda=True, profile_memory=True, row_limit=100)
+    elif name is None:
+        return PassThroughProfiler()
+    else:
+        raise ValueError(f'Invalid profiler: {name}')

vismatch/third_party/MatchFormer/test.py

@@ -0,0 +1,55 @@
+import pytorch_lightning as pl
+import argparse
+import pprint
+from loguru import logger as loguru_logger
+from config.defaultmf import get_cfg_defaults
+from model.data import MultiSceneDataModule
+from model.lightning_loftr import PL_LoFTR
+
+
+def parse_args():
+    # init a costum parser which will be added into pl.Trainer parser
+    # check documentation: https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html#trainer-flags
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        'data_cfg_path', type=str, help='data config path')
+    parser.add_argument(
+        '--ckpt_path', type=str, default="weights/indoor_ds.ckpt", help='path to the checkpoint')
+    parser.add_argument(
+        '--dump_dir', type=str, default=None, help="if set, the matching results will be dump to dump_dir")
+    parser.add_argument(
+        '--profiler_name', type=str, default='inference', help='options: [inference, pytorch], or leave it unset')
+    parser.add_argument(
+        '--batch_size', type=int, default=1, help='batch_size per gpu')
+    parser.add_argument(
+        '--num_workers', type=int, default=2)
+    parser.add_argument(
+        '--thr', type=float, default=None, help='modify the coarse-level matching threshold.')
+
+    parser = pl.Trainer.add_argparse_args(parser)
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    # parse arguments
+    args = parse_args()
+    # init default-cfg and merge it with the main- and data-cfg
+    config = get_cfg_defaults()
+    config.merge_from_file(args.data_cfg_path)
+    pl.seed_everything(config.TRAINER.SEED)  # reproducibility
+
+    # tune when testing
+    if args.thr is not None:
+        config.LOFTR.MATCH_COARSE.THR = args.thr
+
+    # lightning module
+    model = PL_LoFTR(config, pretrained_ckpt=args.ckpt_path, dump_dir=args.dump_dir)
+
+    # lightning data
+    data_module = MultiSceneDataModule(args, config)
+
+    # lightning trainer
+    trainer = pl.Trainer.from_argparse_args(args, replace_sampler_ddp=False, logger=False)
+    
+    loguru_logger.info(f"Start testing!")
+    trainer.test(model, datamodule=data_module, verbose=False)

vismatch/third_party/RIPE/app.py

@@ -0,0 +1,272 @@
+# This is a small gradio interface to access our RIPE keypoint extractor.
+# You can either upload two images or use one of the example image pairs.
+
+import os
+
+import gradio as gr
+from PIL import Image
+
+from ripe import vgg_hyper
+
+SEED = 32000
+os.environ["PYTHONHASHSEED"] = str(SEED)
+
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+
+torch.manual_seed(SEED)
+np.random.seed(SEED)
+random.seed(SEED)
+import cv2
+import kornia.feature as KF
+import kornia.geometry as KG
+
+from ripe.utils.utils import cv2_matches_from_kornia, to_cv_kpts
+
+MIN_SIZE = 512
+MAX_SIZE = 768
+
+description_text = """
+<p align='center'>
+  <h1 align='center'>🌊🌺 ICCV 2025 🌺🌊</h1>
+  <p align='center'>
+    <a href='https://scholar.google.com/citations?user=ybMR38kAAAAJ'>Johannes Künzel</a> · 
+    <a href='https://scholar.google.com/citations?user=5yTuyGIAAAAJ'>Anna Hilsmann</a> · 
+    <a href='https://scholar.google.com/citations?user=BCElyCkAAAAJ'>Peter Eisert</a>
+  </p>
+  <h2 align='center'>
+    <a href='???'>Arxiv</a> | 
+    <a href='???'>Project Page</a> | 
+    <a href='???'>Code</a>
+  </h2>
+</p>
+
+<br/>
+<div align='center'>
+
+### This demo showcases our new keypoint extractor model, RIPE (Reinforcement Learning on Unlabeled Image Pairs for Robust Keypoint Extraction).
+
+### RIPE is trained without requiring pose or depth supervision or artificial augmentations. By leveraging reinforcement learning, it learns to extract keypoints solely based on whether an image pair depicts the same scene or not.
+
+### For more detailed information, please refer to our [paper](link to be added).
+
+The demo code extracts the 2048-top keypoints from the two input images. It uses the mutual nearest neighbor (MNN) descriptor matcher from kornia to find matches between the two images.
+If the number of matches is greater than 8, it applies RANSAC to filter out outliers based on the inlier threshold provided by the user.
+Images are resized to fit within a maximum size of 2048x2048 pixels with maintained aspect ratio.
+
+</div>
+"""
+
+path_weights = Path(
+    "/media/jwkuenzel/work/projects/CVG_Reinforced_Keypoints/output/train/ablation_iccv/inlier_threshold/1571243/2025-02-19/14-00-10_789013/model_inlier_threshold_best.pth"
+)
+
+model = vgg_hyper(path_weights)
+
+
+def get_new_image_size(image, min_size=1600, max_size=2048):
+    """
+    Get a new size for the image that is scaled to fit between min_size and max_size while maintaining the aspect ratio.
+
+    Args:
+        image (PIL.Image): Input image.
+        min_size (int): Minimum allowed size for width and height.
+        max_size (int): Maximum allowed size for width and height.
+
+    Returns:
+        tuple: New size (width, height) for the image.
+    """
+    width, height = image.size
+
+    aspect_ratio = width / height
+    if width > height:
+        new_width = max(min_size, min(max_size, width))
+        new_height = int(new_width / aspect_ratio)
+    else:
+        new_height = max(min_size, min(max_size, height))
+        new_width = int(new_height * aspect_ratio)
+
+    new_size = (new_width, new_height)
+
+    return new_size
+
+
+def extract_keypoints(image1, image2, inl_th):
+    """
+    Extract keypoints from two input images using the RIPE model.
+
+    Args:
+        image1 (PIL.Image): First input image.
+        image2 (PIL.Image): Second input image.
+        inl_th (float): RANSAC inlier threshold.
+
+    Returns:
+        dict: A dictionary containing keypoints and matches.
+    """
+    log_text = "Extracting keypoints and matches with RIPE\n"
+
+    log_text += f"Image 1 size: {image1.size}\n"
+    log_text += f"Image 2 size: {image2.size}\n"
+
+    # check not larger than 2048x2048
+    new_size = get_new_image_size(image1, min_size=MIN_SIZE, max_size=MAX_SIZE)
+    image1 = image1.resize(new_size)
+
+    new_size = get_new_image_size(image2, min_size=MIN_SIZE, max_size=MAX_SIZE)
+    image2 = image2.resize(new_size)
+
+    log_text += f"Resized Image 1 size: {image1.size}\n"
+    log_text += f"Resized Image 2 size: {image2.size}\n"
+
+    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(dev)
+
+    image1 = image1.convert("RGB")
+    image2 = image2.convert("RGB")
+
+    image1_original = image1.copy()
+    image2_original = image2.copy()
+
+    # convert PIL images to numpy arrays
+    image1_original = np.array(image1_original)
+    image2_original = np.array(image2_original)
+
+    # convert PIL images to tensors
+    image1 = torch.tensor(np.array(image1)).permute(2, 0, 1).float() / 255.0
+    image2 = torch.tensor(np.array(image2)).permute(2, 0, 1).float() / 255.0
+
+    image1 = image1.to(dev).unsqueeze(0)  # Add batch dimension
+    image2 = image2.to(dev).unsqueeze(0)  # Add batch dimension
+
+    kpts_1, desc_1, score_1 = model.detectAndCompute(image1, threshold=0.5, top_k=2048)
+    kpts_2, desc_2, score_2 = model.detectAndCompute(image2, threshold=0.5, top_k=2048)
+
+    log_text += f"Number of keypoints in image 1: {kpts_1.shape[0]}\n"
+    log_text += f"Number of keypoints in image 2: {kpts_2.shape[0]}\n"
+
+    matcher = KF.DescriptorMatcher("mnn")  # threshold is not used with mnn
+    match_dists, match_idxs = matcher(desc_1, desc_2)
+
+    log_text += f"Number of MNN matches: {match_idxs.shape[0]}\n"
+
+    cv2_matches = cv2_matches_from_kornia(match_dists, match_idxs)
+
+    do_ransac = match_idxs.shape[0] > 8
+
+    if do_ransac:
+        matched_pts_1 = kpts_1[match_idxs[:, 0]]
+        matched_pts_2 = kpts_2[match_idxs[:, 1]]
+
+        H, mask = KG.ransac.RANSAC(model_type="fundamental", inl_th=inl_th)(matched_pts_1, matched_pts_2)
+        matchesMask = mask.int().ravel().tolist()
+
+        log_text += f"RANSAC found {mask.sum().item()} inliers out of {mask.shape[0]} matches with an inlier threshold of {inl_th}.\n"
+    else:
+        log_text += "Not enough matches for RANSAC, skipping RANSAC step.\n"
+
+    kpts_1 = to_cv_kpts(kpts_1, score_1)
+    kpts_2 = to_cv_kpts(kpts_2, score_2)
+
+    keypoints_raw_1 = cv2.drawKeypoints(image1_original, kpts_1, image1_original, color=(0, 255, 0))
+    keypoints_raw_2 = cv2.drawKeypoints(image2_original, kpts_2, image2_original, color=(0, 255, 0))
+
+    # pad height smaller image to match the height of the larger image
+    if keypoints_raw_1.shape[0] < keypoints_raw_2.shape[0]:
+        pad_height = keypoints_raw_2.shape[0] - keypoints_raw_1.shape[0]
+        keypoints_raw_1 = np.pad(
+            keypoints_raw_1, ((0, pad_height), (0, 0), (0, 0)), mode="constant", constant_values=255
+        )
+    elif keypoints_raw_1.shape[0] > keypoints_raw_2.shape[0]:
+        pad_height = keypoints_raw_1.shape[0] - keypoints_raw_2.shape[0]
+        keypoints_raw_2 = np.pad(
+            keypoints_raw_2, ((0, pad_height), (0, 0), (0, 0)), mode="constant", constant_values=255
+        )
+
+    # concatenate keypoints images horizontally
+    keypoints_raw = np.concatenate((keypoints_raw_1, keypoints_raw_2), axis=1)
+    keypoints_raw_pil = Image.fromarray(keypoints_raw)
+
+    result_raw = cv2.drawMatches(
+        image1_original,
+        kpts_1,
+        image2_original,
+        kpts_2,
+        cv2_matches,
+        None,
+        matchColor=(0, 255, 0),
+        matchesMask=None,
+        # matchesMask=None,
+        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS,
+    )
+
+    if not do_ransac:
+        result_ransac = None
+    else:
+        result_ransac = cv2.drawMatches(
+            image1_original,
+            kpts_1,
+            image2_original,
+            kpts_2,
+            cv2_matches,
+            None,
+            matchColor=(0, 255, 0),
+            matchesMask=matchesMask,
+            singlePointColor=(0, 0, 255),
+            flags=cv2.DrawMatchesFlags_DEFAULT,
+        )
+
+    # result = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB for display
+
+    # convert to PIL Image
+    result_raw_pil = Image.fromarray(result_raw)
+    if result_ransac is not None:
+        result_ransac_pil = Image.fromarray(result_ransac)
+    else:
+        result_ransac_pil = None
+
+    return log_text, result_ransac_pil, result_raw_pil, keypoints_raw_pil
+
+
+demo = gr.Interface(
+    fn=extract_keypoints,
+    inputs=[
+        gr.Image(type="pil", label="Image 1"),
+        gr.Image(type="pil", label="Image 2"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=3.0,
+            step=0.1,
+            value=0.5,
+            label="RANSAC inlier threshold",
+            info="Threshold for RANSAC inlier detection. Lower values may yield fewer inliers but more robust matches.",
+        ),
+    ],
+    outputs=[
+        gr.Textbox(type="text", label="Log"),
+        gr.Image(type="pil", label="Keypoints and Matches (RANSAC)"),
+        gr.Image(type="pil", label="Keypoints and Matches"),
+        gr.Image(type="pil", label="Keypoint Detection Results"),
+    ],
+    title="RIPE: Reinforcement Learning on Unlabeled Image Pairs for Robust Keypoint Extraction",
+    description=description_text,
+    examples=[
+        [
+            "assets_gradio/all_souls_000013.jpg",
+            "assets_gradio/all_souls_000055.jpg",
+        ],
+        [
+            "assets_gradio/167170681_0e5c42fd21_o.jpg",
+            "assets_gradio/170804731_6bf4fbecd4_o.jpg",
+        ],
+        [
+            "assets_gradio/4171014767_0fe879b783_o.jpg",
+            "assets_gradio/4174108353_20422632d6_o.jpg",
+        ],
+    ],
+    flagging_mode="never",
+    theme="default",
+)
+demo.launch()