vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/MatchAnything/imcui/hloc/utils/viz.py

@@ -0,0 +1,146 @@
+"""
+2D visualization primitives based on Matplotlib.
+
+1) Plot images with `plot_images`.
+2) Call `plot_keypoints` or `plot_matches` any number of times.
+3) Optionally: save a .png or .pdf plot (nice in papers!) with `save_plot`.
+"""
+
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.patheffects as path_effects
+import numpy as np
+
+
+def cm_RdGn(x):
+    """Custom colormap: red (0) -> yellow (0.5) -> green (1)."""
+    x = np.clip(x, 0, 1)[..., None] * 2
+    c = x * np.array([[0, 1.0, 0]]) + (2 - x) * np.array([[1.0, 0, 0]])
+    return np.clip(c, 0, 1)
+
+
+def plot_images(
+    imgs, titles=None, cmaps="gray", dpi=100, pad=0.5, adaptive=True, figsize=4.5
+):
+    """Plot a set of images horizontally.
+    Args:
+        imgs: a list of NumPy or PyTorch images, RGB (H, W, 3) or mono (H, W).
+        titles: a list of strings, as titles for each image.
+        cmaps: colormaps for monochrome images.
+        adaptive: whether the figure size should fit the image aspect ratios.
+    """
+    n = len(imgs)
+    if not isinstance(cmaps, (list, tuple)):
+        cmaps = [cmaps] * n
+
+    if adaptive:
+        ratios = [i.shape[1] / i.shape[0] for i in imgs]  # W / H
+    else:
+        ratios = [4 / 3] * n
+    figsize = [sum(ratios) * figsize, figsize]
+    fig, axs = plt.subplots(
+        1, n, figsize=figsize, dpi=dpi, gridspec_kw={"width_ratios": ratios}
+    )
+    if n == 1:
+        axs = [axs]
+    for i, (img, ax) in enumerate(zip(imgs, axs)):
+        ax.imshow(img, cmap=plt.get_cmap(cmaps[i]))
+        ax.set_axis_off()
+        if titles:
+            ax.set_title(titles[i])
+    fig.tight_layout(pad=pad)
+    return fig
+
+
+# def plot_keypoints(kpts, colors="lime", ps=4):
+def plot_keypoints(kpts, colors=(0.8392925797770089, 0.1845444059976932, 0.1528642829680892), ps=4):
+    """Plot keypoints for existing images.
+    Args:
+        kpts: list of ndarrays of size (N, 2).
+        colors: string, or list of list of tuples (one for each keypoints).
+        ps: size of the keypoints as float.
+    """
+    if not isinstance(colors, list):
+        colors = [colors] * len(kpts)
+    axes = plt.gcf().axes
+    try:
+        for a, k, c in zip(axes, kpts, colors):
+            a.scatter(k[:, 0], k[:, 1], c=c, s=ps, linewidths=0)
+    except IndexError:
+        pass
+
+
+def plot_matches(kpts0, kpts1, color=None, lw=1.5, ps=4, indices=(0, 1), a=1.0):
+    """Plot matches for a pair of existing images.
+    Args:
+        kpts0, kpts1: corresponding keypoints of size (N, 2).
+        color: color of each match, string or RGB tuple. Random if not given.
+        lw: width of the lines.
+        ps: size of the end points (no endpoint if ps=0)
+        indices: indices of the images to draw the matches on.
+        a: alpha opacity of the match lines.
+    """
+    fig = plt.gcf()
+    ax = fig.axes
+    assert len(ax) > max(indices)
+    ax0, ax1 = ax[indices[0]], ax[indices[1]]
+    fig.canvas.draw()
+
+    assert len(kpts0) == len(kpts1)
+    if color is None:
+        color = matplotlib.cm.hsv(np.random.rand(len(kpts0))).tolist()
+    elif len(color) > 0 and not isinstance(color[0], (tuple, list)):
+        color = [color] * len(kpts0)
+
+    if lw > 0:
+        # transform the points into the figure coordinate system
+        for i in range(len(kpts0)):
+            fig.add_artist(
+                matplotlib.patches.ConnectionPatch(
+                    xyA=(kpts0[i, 0], kpts0[i, 1]),
+                    coordsA=ax0.transData,
+                    xyB=(kpts1[i, 0], kpts1[i, 1]),
+                    coordsB=ax1.transData,
+                    zorder=1,
+                    color=color[i],
+                    linewidth=lw,
+                    alpha=a,
+                )
+            )
+
+    # freeze the axes to prevent the transform to change
+    ax0.autoscale(enable=False)
+    ax1.autoscale(enable=False)
+
+    if ps > 0:
+        ax0.scatter(kpts0[:, 0], kpts0[:, 1], c=color, s=ps)
+        ax1.scatter(kpts1[:, 0], kpts1[:, 1], c=color, s=ps)
+
+
+def add_text(
+    idx,
+    text,
+    pos=(0.01, 0.99),
+    fs=15,
+    color="w",
+    lcolor="k",
+    lwidth=2,
+    ha="left",
+    va="top",
+):
+    ax = plt.gcf().axes[idx]
+    t = ax.text(
+        *pos, text, fontsize=fs, ha=ha, va=va, color=color, transform=ax.transAxes
+    )
+    if lcolor is not None:
+        t.set_path_effects(
+            [
+                path_effects.Stroke(linewidth=lwidth, foreground=lcolor),
+                path_effects.Normal(),
+            ]
+        )
+
+
+def save_plot(path, **kw):
+    """Save the current figure without any white margin."""
+    plt.savefig(path, bbox_inches="tight", pad_inches=0, **kw)

vismatch/third_party/MatchAnything/imcui/hloc/utils/viz_3d.py

@@ -0,0 +1,203 @@
+"""
+3D visualization based on plotly.
+Works for a small number of points and cameras, might be slow otherwise.
+
+1) Initialize a figure with `init_figure`
+2) Add 3D points, camera frustums, or both as a pycolmap.Reconstruction
+
+Written by Paul-Edouard Sarlin and Philipp Lindenberger.
+"""
+
+from typing import Optional
+
+import numpy as np
+import plotly.graph_objects as go
+import pycolmap
+
+
+def to_homogeneous(points):
+    pad = np.ones((points.shape[:-1] + (1,)), dtype=points.dtype)
+    return np.concatenate([points, pad], axis=-1)
+
+
+def init_figure(height: int = 800) -> go.Figure:
+    """Initialize a 3D figure."""
+    fig = go.Figure()
+    axes = dict(
+        visible=False,
+        showbackground=False,
+        showgrid=False,
+        showline=False,
+        showticklabels=True,
+        autorange=True,
+    )
+    fig.update_layout(
+        template="plotly_dark",
+        height=height,
+        scene_camera=dict(
+            eye=dict(x=0.0, y=-0.1, z=-2),
+            up=dict(x=0, y=-1.0, z=0),
+            projection=dict(type="orthographic"),
+        ),
+        scene=dict(
+            xaxis=axes,
+            yaxis=axes,
+            zaxis=axes,
+            aspectmode="data",
+            dragmode="orbit",
+        ),
+        margin=dict(l=0, r=0, b=0, t=0, pad=0),
+        legend=dict(orientation="h", yanchor="top", y=0.99, xanchor="left", x=0.1),
+    )
+    return fig
+
+
+def plot_points(
+    fig: go.Figure,
+    pts: np.ndarray,
+    color: str = "rgba(255, 0, 0, 1)",
+    ps: int = 2,
+    colorscale: Optional[str] = None,
+    name: Optional[str] = None,
+):
+    """Plot a set of 3D points."""
+    x, y, z = pts.T
+    tr = go.Scatter3d(
+        x=x,
+        y=y,
+        z=z,
+        mode="markers",
+        name=name,
+        legendgroup=name,
+        marker=dict(size=ps, color=color, line_width=0.0, colorscale=colorscale),
+    )
+    fig.add_trace(tr)
+
+
+def plot_camera(
+    fig: go.Figure,
+    R: np.ndarray,
+    t: np.ndarray,
+    K: np.ndarray,
+    color: str = "rgb(0, 0, 255)",
+    name: Optional[str] = None,
+    legendgroup: Optional[str] = None,
+    fill: bool = False,
+    size: float = 1.0,
+    text: Optional[str] = None,
+):
+    """Plot a camera frustum from pose and intrinsic matrix."""
+    W, H = K[0, 2] * 2, K[1, 2] * 2
+    corners = np.array([[0, 0], [W, 0], [W, H], [0, H], [0, 0]])
+    if size is not None:
+        image_extent = max(size * W / 1024.0, size * H / 1024.0)
+        world_extent = max(W, H) / (K[0, 0] + K[1, 1]) / 0.5
+        scale = 0.5 * image_extent / world_extent
+    else:
+        scale = 1.0
+    corners = to_homogeneous(corners) @ np.linalg.inv(K).T
+    corners = (corners / 2 * scale) @ R.T + t
+    legendgroup = legendgroup if legendgroup is not None else name
+
+    x, y, z = np.concatenate(([t], corners)).T
+    i = [0, 0, 0, 0]
+    j = [1, 2, 3, 4]
+    k = [2, 3, 4, 1]
+
+    if fill:
+        pyramid = go.Mesh3d(
+            x=x,
+            y=y,
+            z=z,
+            color=color,
+            i=i,
+            j=j,
+            k=k,
+            legendgroup=legendgroup,
+            name=name,
+            showlegend=False,
+            hovertemplate=text.replace("\n", "<br>"),
+        )
+        fig.add_trace(pyramid)
+
+    triangles = np.vstack((i, j, k)).T
+    vertices = np.concatenate(([t], corners))
+    tri_points = np.array([vertices[i] for i in triangles.reshape(-1)])
+    x, y, z = tri_points.T
+
+    pyramid = go.Scatter3d(
+        x=x,
+        y=y,
+        z=z,
+        mode="lines",
+        legendgroup=legendgroup,
+        name=name,
+        line=dict(color=color, width=1),
+        showlegend=False,
+        hovertemplate=text.replace("\n", "<br>"),
+    )
+    fig.add_trace(pyramid)
+
+
+def plot_camera_colmap(
+    fig: go.Figure,
+    image: pycolmap.Image,
+    camera: pycolmap.Camera,
+    name: Optional[str] = None,
+    **kwargs,
+):
+    """Plot a camera frustum from PyCOLMAP objects"""
+    world_t_camera = image.cam_from_world.inverse()
+    plot_camera(
+        fig,
+        world_t_camera.rotation.matrix(),
+        world_t_camera.translation,
+        camera.calibration_matrix(),
+        name=name or str(image.image_id),
+        text=str(image),
+        **kwargs,
+    )
+
+
+def plot_cameras(fig: go.Figure, reconstruction: pycolmap.Reconstruction, **kwargs):
+    """Plot a camera as a cone with camera frustum."""
+    for image_id, image in reconstruction.images.items():
+        plot_camera_colmap(
+            fig, image, reconstruction.cameras[image.camera_id], **kwargs
+        )
+
+
+def plot_reconstruction(
+    fig: go.Figure,
+    rec: pycolmap.Reconstruction,
+    max_reproj_error: float = 6.0,
+    color: str = "rgb(0, 0, 255)",
+    name: Optional[str] = None,
+    min_track_length: int = 2,
+    points: bool = True,
+    cameras: bool = True,
+    points_rgb: bool = True,
+    cs: float = 1.0,
+):
+    # Filter outliers
+    bbs = rec.compute_bounding_box(0.001, 0.999)
+    # Filter points, use original reproj error here
+    p3Ds = [
+        p3D
+        for _, p3D in rec.points3D.items()
+        if (
+            (p3D.xyz >= bbs[0]).all()
+            and (p3D.xyz <= bbs[1]).all()
+            and p3D.error <= max_reproj_error
+            and p3D.track.length() >= min_track_length
+        )
+    ]
+    xyzs = [p3D.xyz for p3D in p3Ds]
+    if points_rgb:
+        pcolor = [p3D.color for p3D in p3Ds]
+    else:
+        pcolor = color
+    if points:
+        plot_points(fig, np.array(xyzs), color=pcolor, ps=1, name=name)
+    if cameras:
+        plot_cameras(fig, rec, color=color, legendgroup=name, size=cs)

vismatch/third_party/MatchAnything/imcui/hloc/visualization.py

@@ -0,0 +1,178 @@
+import pickle
+import random
+
+import numpy as np
+import pycolmap
+from matplotlib import cm
+
+from .utils.io import read_image
+from .utils.viz import (
+    add_text,
+    cm_RdGn,
+    plot_images,
+    plot_keypoints,
+    plot_matches,
+)
+
+
+def visualize_sfm_2d(
+    reconstruction,
+    image_dir,
+    color_by="visibility",
+    selected=[],
+    n=1,
+    seed=0,
+    dpi=75,
+):
+    assert image_dir.exists()
+    if not isinstance(reconstruction, pycolmap.Reconstruction):
+        reconstruction = pycolmap.Reconstruction(reconstruction)
+
+    if not selected:
+        image_ids = reconstruction.reg_image_ids()
+        selected = random.Random(seed).sample(image_ids, min(n, len(image_ids)))
+
+    for i in selected:
+        image = reconstruction.images[i]
+        keypoints = np.array([p.xy for p in image.points2D])
+        visible = np.array([p.has_point3D() for p in image.points2D])
+
+        if color_by == "visibility":
+            color = [(0, 0, 1) if v else (1, 0, 0) for v in visible]
+            text = f"visible: {np.count_nonzero(visible)}/{len(visible)}"
+        elif color_by == "track_length":
+            tl = np.array(
+                [
+                    (
+                        reconstruction.points3D[p.point3D_id].track.length()
+                        if p.has_point3D()
+                        else 1
+                    )
+                    for p in image.points2D
+                ]
+            )
+            max_, med_ = np.max(tl), np.median(tl[tl > 1])
+            tl = np.log(tl)
+            color = cm.jet(tl / tl.max()).tolist()
+            text = f"max/median track length: {max_}/{med_}"
+        elif color_by == "depth":
+            p3ids = [p.point3D_id for p in image.points2D if p.has_point3D()]
+            z = np.array(
+                [
+                    (image.cam_from_world * reconstruction.points3D[j].xyz)[-1]
+                    for j in p3ids
+                ]
+            )
+            z -= z.min()
+            color = cm.jet(z / np.percentile(z, 99.9))
+            text = f"visible: {np.count_nonzero(visible)}/{len(visible)}"
+            keypoints = keypoints[visible]
+        else:
+            raise NotImplementedError(f"Coloring not implemented: {color_by}.")
+
+        name = image.name
+        fig = plot_images([read_image(image_dir / name)], dpi=dpi)
+        plot_keypoints([keypoints], colors=[color], ps=4)
+        add_text(0, text)
+        add_text(0, name, pos=(0.01, 0.01), fs=5, lcolor=None, va="bottom")
+    return fig
+
+
+def visualize_loc(
+    results,
+    image_dir,
+    reconstruction=None,
+    db_image_dir=None,
+    selected=[],
+    n=1,
+    seed=0,
+    prefix=None,
+    **kwargs,
+):
+    assert image_dir.exists()
+
+    with open(str(results) + "_logs.pkl", "rb") as f:
+        logs = pickle.load(f)
+
+    if not selected:
+        queries = list(logs["loc"].keys())
+        if prefix:
+            queries = [q for q in queries if q.startswith(prefix)]
+        selected = random.Random(seed).sample(queries, min(n, len(queries)))
+
+    if reconstruction is not None:
+        if not isinstance(reconstruction, pycolmap.Reconstruction):
+            reconstruction = pycolmap.Reconstruction(reconstruction)
+
+    for qname in selected:
+        loc = logs["loc"][qname]
+        visualize_loc_from_log(
+            image_dir, qname, loc, reconstruction, db_image_dir, **kwargs
+        )
+
+
+def visualize_loc_from_log(
+    image_dir,
+    query_name,
+    loc,
+    reconstruction=None,
+    db_image_dir=None,
+    top_k_db=2,
+    dpi=75,
+):
+    q_image = read_image(image_dir / query_name)
+    if loc.get("covisibility_clustering", False):
+        # select the first, largest cluster if the localization failed
+        loc = loc["log_clusters"][loc["best_cluster"] or 0]
+
+    inliers = np.array(loc["PnP_ret"]["inliers"])
+    mkp_q = loc["keypoints_query"]
+    n = len(loc["db"])
+    if reconstruction is not None:
+        # for each pair of query keypoint and its matched 3D point,
+        # we need to find its corresponding keypoint in each database image
+        # that observes it. We also count the number of inliers in each.
+        kp_idxs, kp_to_3D_to_db = loc["keypoint_index_to_db"]
+        counts = np.zeros(n)
+        dbs_kp_q_db = [[] for _ in range(n)]
+        inliers_dbs = [[] for _ in range(n)]
+        for i, (inl, (p3D_id, db_idxs)) in enumerate(zip(inliers, kp_to_3D_to_db)):
+            track = reconstruction.points3D[p3D_id].track
+            track = {el.image_id: el.point2D_idx for el in track.elements}
+            for db_idx in db_idxs:
+                counts[db_idx] += inl
+                kp_db = track[loc["db"][db_idx]]
+                dbs_kp_q_db[db_idx].append((i, kp_db))
+                inliers_dbs[db_idx].append(inl)
+    else:
+        # for inloc the database keypoints are already in the logs
+        assert "keypoints_db" in loc
+        assert "indices_db" in loc
+        counts = np.array([np.sum(loc["indices_db"][inliers] == i) for i in range(n)])
+
+    # display the database images with the most inlier matches
+    db_sort = np.argsort(-counts)
+    for db_idx in db_sort[:top_k_db]:
+        if reconstruction is not None:
+            db = reconstruction.images[loc["db"][db_idx]]
+            db_name = db.name
+            db_kp_q_db = np.array(dbs_kp_q_db[db_idx])
+            kp_q = mkp_q[db_kp_q_db[:, 0]]
+            kp_db = np.array([db.points2D[i].xy for i in db_kp_q_db[:, 1]])
+            inliers_db = inliers_dbs[db_idx]
+        else:
+            db_name = loc["db"][db_idx]
+            kp_q = mkp_q[loc["indices_db"] == db_idx]
+            kp_db = loc["keypoints_db"][loc["indices_db"] == db_idx]
+            inliers_db = inliers[loc["indices_db"] == db_idx]
+
+        db_image = read_image((db_image_dir or image_dir) / db_name)
+        color = cm_RdGn(inliers_db).tolist()
+        text = f"inliers: {sum(inliers_db)}/{len(inliers_db)}"
+
+        plot_images([q_image, db_image], dpi=dpi)
+        plot_matches(kp_q, kp_db, color, a=0.1)
+        add_text(0, text)
+        opts = dict(pos=(0.01, 0.01), fs=5, lcolor=None, va="bottom")
+        add_text(0, query_name, **opts)
+        add_text(1, db_name, **opts)

vismatch/third_party/MatchAnything/imcui/third_party/MatchAnything/configs/models/eloftr_model.py

@@ -0,0 +1,128 @@
+from src.config.default import _CN as cfg
+
+cfg.LOFTR.MATCH_COARSE.MATCH_TYPE = 'dual_softmax'
+cfg.LOFTR.MATCH_COARSE.SPARSE_SPVS = False
+
+cfg.TRAINER.CANONICAL_LR = 8e-3
+cfg.TRAINER.WARMUP_STEP = 1875  # 3 epochs
+cfg.TRAINER.WARMUP_RATIO = 0.1
+
+cfg.TRAINER.MSLR_MILESTONES = [4, 6, 8, 10, 12, 14, 16]
+
+# pose estimation
+cfg.TRAINER.RANSAC_PIXEL_THR = 0.5
+
+cfg.TRAINER.OPTIMIZER = "adamw"
+cfg.TRAINER.ADAMW_DECAY = 0.1
+
+cfg.LOFTR.MATCH_COARSE.TRAIN_COARSE_PERCENT = 0.1
+
+cfg.LOFTR.MATCH_COARSE.MTD_SPVS = True
+cfg.LOFTR.FINE.MTD_SPVS = True
+
+cfg.LOFTR.RESOLUTION = (8, 1)  # options: [(8, 2), (16, 4)]
+cfg.LOFTR.FINE_WINDOW_SIZE = 8  # window_size in fine_level, must be odd
+cfg.LOFTR.MATCH_FINE.THR = 0
+cfg.LOFTR.LOSS.FINE_TYPE = 'l2'  # ['l2_with_std', 'l2']
+
+cfg.TRAINER.EPI_ERR_THR = 5e-4 # recommendation: 5e-4 for ScanNet, 1e-4 for MegaDepth (from SuperGlue)
+
+cfg.LOFTR.MATCH_COARSE.SPARSE_SPVS = True
+
+# PAN
+cfg.LOFTR.COARSE.PAN = True
+cfg.LOFTR.COARSE.POOl_SIZE = 4
+cfg.LOFTR.COARSE.BN = False
+cfg.LOFTR.COARSE.XFORMER = True
+cfg.LOFTR.COARSE.ATTENTION = 'full'  # options: ['linear', 'full']
+
+cfg.LOFTR.FINE.PAN = False
+cfg.LOFTR.FINE.POOl_SIZE = 4
+cfg.LOFTR.FINE.BN = False
+cfg.LOFTR.FINE.XFORMER = False
+
+# noalign
+cfg.LOFTR.ALIGN_CORNER = False
+
+# fp16
+cfg.DATASET.FP16 = False
+cfg.LOFTR.FP16 = False
+
+# DEBUG
+cfg.LOFTR.FP16LOG = False
+cfg.LOFTR.MATCH_COARSE.FP16LOG = False
+
+# fine skip
+cfg.LOFTR.FINE.SKIP = True
+
+# clip
+cfg.TRAINER.GRADIENT_CLIPPING = 0.5
+
+# backbone
+cfg.LOFTR.BACKBONE_TYPE = 'RepVGG'
+
+# A1
+cfg.LOFTR.RESNETFPN.INITIAL_DIM = 64
+cfg.LOFTR.RESNETFPN.BLOCK_DIMS = [64, 128, 256]  # s1, s2, s3
+cfg.LOFTR.COARSE.D_MODEL = 256
+cfg.LOFTR.FINE.D_MODEL = 64
+
+# FPN backbone_inter_feat with coarse_attn.
+cfg.LOFTR.COARSE_FEAT_ONLY = True
+cfg.LOFTR.INTER_FEAT = True
+cfg.LOFTR.RESNETFPN.COARSE_FEAT_ONLY = True
+cfg.LOFTR.RESNETFPN.INTER_FEAT = True
+
+# loop back spv coarse match
+cfg.LOFTR.FORCE_LOOP_BACK = False
+
+# fix norm fine match
+cfg.LOFTR.MATCH_FINE.NORMFINEM = True
+
+# loss cf weight
+cfg.LOFTR.LOSS.COARSE_OVERLAP_WEIGHT = True
+cfg.LOFTR.LOSS.FINE_OVERLAP_WEIGHT = True
+
+# leaky relu
+cfg.LOFTR.RESNETFPN.LEAKY = False
+cfg.LOFTR.COARSE.LEAKY = 0.01
+
+# prevent FP16 OVERFLOW in dirty data
+cfg.LOFTR.NORM_FPNFEAT = True
+cfg.LOFTR.REPLACE_NAN = True
+
+# force mutual nearest
+cfg.LOFTR.MATCH_COARSE.FORCE_NEAREST = True
+cfg.LOFTR.MATCH_COARSE.THR = 0.1
+
+# fix fine matching
+cfg.LOFTR.MATCH_FINE.FIX_FINE_MATCHING = True
+
+# dwconv
+cfg.LOFTR.COARSE.DWCONV = True
+
+# localreg
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS = True
+cfg.LOFTR.LOSS.LOCAL_WEIGHT = 0.25
+
+# it5
+cfg.LOFTR.EVAL_TIMES = 1
+
+# rope
+cfg.LOFTR.COARSE.ROPE = True
+
+# local regress temperature
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS_TEMPERATURE = 10.0
+
+# SLICE
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS_SLICE = True
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS_SLICEDIM = 8
+
+# inner with no mask [64,100]
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS_INNER = True
+cfg.LOFTR.MATCH_FINE.LOCAL_REGRESS_NOMASK = True
+
+cfg.LOFTR.MATCH_FINE.TOPK = 1
+cfg.LOFTR.MATCH_COARSE.FINE_TOPK = 1
+
+cfg.LOFTR.MATCH_COARSE.FP16MATMUL = False

vismatch/third_party/MatchAnything/imcui/third_party/MatchAnything/configs/models/roma_model.py

@@ -0,0 +1,27 @@
+from src.config.default import _CN as cfg
+cfg.ROMA.RESIZE_BY_STRETCH = True
+cfg.DATASET.RESIZE_BY_STRETCH = True
+
+cfg.TRAINER.CANONICAL_LR = 8e-3
+cfg.TRAINER.WARMUP_STEP = 1875  # 3 epochs
+cfg.TRAINER.WARMUP_RATIO = 0.1
+
+cfg.TRAINER.MSLR_MILESTONES = [4, 6, 8, 10, 12, 14, 16, 18, 20]
+
+# pose estimation
+cfg.TRAINER.RANSAC_PIXEL_THR = 0.5
+
+cfg.TRAINER.OPTIMIZER = "adamw"
+cfg.TRAINER.ADAMW_DECAY = 0.1
+cfg.TRAINER.OPTIMIZER_EPS = 5e-7
+
+cfg.TRAINER.EPI_ERR_THR = 5e-4
+
+# fp16
+cfg.DATASET.FP16 = False
+cfg.LOFTR.FP16 = True
+
+# clip
+cfg.TRAINER.GRADIENT_CLIPPING = 0.5
+
+cfg.LOFTR.ROMA_LOSS.IGNORE_EMPTY_IN_SPARSE_MATCH_SPV = True

vismatch/third_party/MatchAnything/imcui/third_party/MatchAnything/notebooks/notebooks_utils/__init__.py

@@ -0,0 +1 @@
+from .plotting import *