update: using imcui pkg

.gitattributes

@@ -39,3 +39,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.bmp filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text
+*.whl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -26,3 +26,4 @@ gen_example.py
 datasets/lines/terrace0.JPG
 datasets/lines/terrace1.JPG
 datasets/South-Building*
+.ruff_cache

.pre-commit-config.yaml

@@ -0,0 +1,88 @@
+# To use:
+#
+#     pre-commit run -a
+#
+# Or:
+#
+#     pre-commit run --all-files
+#
+# Or:
+#
+#     pre-commit install  # (runs every time you commit in git)
+#
+# To update this file:
+#
+#     pre-commit autoupdate
+#
+# See https://github.com/pre-commit/pre-commit
+
+ci:
+  autoupdate_commit_msg: "chore: update pre-commit hooks"
+  autofix_commit_msg: "style: pre-commit fixes"
+
+repos:
+# Standard hooks
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v5.0.0
+  hooks:
+  - id: check-added-large-files
+    exclude: ^imcui/third_party/
+  - id: check-case-conflict
+    exclude: ^imcui/third_party/
+  - id: check-merge-conflict
+    exclude: ^imcui/third_party/
+  - id: check-symlinks
+    exclude: ^imcui/third_party/
+  - id: check-yaml
+    exclude: ^imcui/third_party/
+  - id: debug-statements
+    exclude: ^imcui/third_party/
+  - id: end-of-file-fixer
+    exclude: ^imcui/third_party/
+  - id: mixed-line-ending
+    exclude: ^imcui/third_party/
+  - id: requirements-txt-fixer
+    exclude: ^imcui/third_party/
+  - id: trailing-whitespace
+    exclude: ^imcui/third_party/
+
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: "v0.8.4"
+  hooks:
+    - id: ruff
+      args: ["--fix", "--show-fixes", "--extend-ignore=E402"]
+    - id: ruff-format
+      exclude: ^(docs|imcui/third_party/)
+
+# Checking static types
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: "v1.14.0"
+  hooks:
+    - id: mypy
+      files: "setup.py"
+      args: []
+      additional_dependencies: [types-setuptools]
+      exclude: ^imcui/third_party/
+# Changes tabs to spaces
+- repo: https://github.com/Lucas-C/pre-commit-hooks
+  rev: v1.5.5
+  hooks:
+  - id: remove-tabs
+    exclude: ^(docs|imcui/third_party/)
+
+# CMake formatting
+- repo: https://github.com/cheshirekow/cmake-format-precommit
+  rev: v0.6.13
+  hooks:
+  - id: cmake-format
+    additional_dependencies: [pyyaml]
+    types: [file]
+    files: (\.cmake|CMakeLists.txt)(.in)?$
+    exclude: ^imcui/third_party/
+
+# Suggested hook if you add a .clang-format file
+- repo: https://github.com/pre-commit/mirrors-clang-format
+  rev: v13.0.0
+  hooks:
+  - id: clang-format
+    exclude: ^imcui/third_party/

Dockerfile

@@ -1,27 +0,0 @@
-# Use an official conda-based Python image as a parent image
-FROM pytorch/pytorch:2.4.0-cuda12.1-cudnn9-runtime
-LABEL maintainer vincentqyw
-ARG PYTHON_VERSION=3.10.10
-
-# Set the working directory to /code
-WORKDIR /code
-
-# Install Git and Git LFS
-RUN apt-get update && apt-get install -y git-lfs
-RUN git lfs install
-
-# Clone the Git repository
-RUN git clone https://huggingface.co/spaces/Realcat/image-matching-webui /code
-
-RUN conda create -n imw python=${PYTHON_VERSION}
-RUN echo "source activate imw" > ~/.bashrc
-ENV PATH /opt/conda/envs/imw/bin:$PATH
-
-# Make RUN commands use the new environment
-SHELL ["conda", "run", "-n", "imw", "/bin/bash", "-c"]
-RUN pip install --upgrade pip
-RUN pip install -r requirements.txt
-RUN apt-get update && apt-get install ffmpeg libsm6 libxext6 -y
-
-# Export port
-EXPOSE 7860

README.md

@@ -1,155 +0,0 @@
----
-title: Imatchui
-emoji: 🚀
-colorFrom: green
-colorTo: purple
-sdk: gradio
-sdk_version: 5.4.0
-app_file: app.py
-pinned: true
-license: apache-2.0
----
-
-[![Contributors][contributors-shield]][contributors-url]
-[![Forks][forks-shield]][forks-url]
-[![Stargazers][stars-shield]][stars-url]
-[![Issues][issues-shield]][issues-url]
-
-<p align="center">
-  <h1 align="center"><br><ins>Image Matching WebUI</ins><br>Identify matching points between two images</h1> 
-</p>
-
-## Description
-
-This simple tool efficiently matches image pairs using multiple famous image matching algorithms. The tool features a Graphical User Interface (GUI) designed using [gradio](https://gradio.app/). You can effortlessly select two images and a matching algorithm and obtain a precise matching result.
-**Note**: the images source can be either local images or webcam images.
-
-Try it on <a href='https://huggingface.co/spaces/Realcat/image-matching-webui'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue'></a> 
-<a target="_blank" href="https://lightning.ai/realcat/studios/image-matching-webui">
-  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/studio-badge.svg" alt="Open In Studio"/>
-</a>
-
-Here is a demo of the tool:
-
-![demo](assets/demo.gif)
-
-The tool currently supports various popular image matching algorithms, namely:
-- [x] [EfficientLoFTR](https://github.com/zju3dv/EfficientLoFTR), CVPR 2024
-- [x] [MASt3R](https://github.com/naver/mast3r), CVPR 2024
-- [x] [DUSt3R](https://github.com/naver/dust3r), CVPR 2024
-- [x] [OmniGlue](https://github.com/Vincentqyw/omniglue-onnx), CVPR 2024
-- [x] [XFeat](https://github.com/verlab/accelerated_features), CVPR 2024
-- [x] [RoMa](https://github.com/Vincentqyw/RoMa), CVPR 2024
-- [x] [DeDoDe](https://github.com/Parskatt/DeDoDe), 3DV 2024
-- [ ] [Mickey](https://github.com/nianticlabs/mickey), CVPR 2024
-- [x] [GIM](https://github.com/xuelunshen/gim), ICLR 2024
-- [ ] [DUSt3R](https://github.com/naver/dust3r), arXiv 2023
-- [x] [LightGlue](https://github.com/cvg/LightGlue), ICCV 2023
-- [x] [DarkFeat](https://github.com/THU-LYJ-Lab/DarkFeat), AAAI 2023
-- [x] [SFD2](https://github.com/feixue94/sfd2), CVPR 2023
-- [x] [IMP](https://github.com/feixue94/imp-release), CVPR 2023
-- [ ] [ASTR](https://github.com/ASTR2023/ASTR), CVPR 2023
-- [ ] [SEM](https://github.com/SEM2023/SEM), CVPR 2023
-- [ ] [DeepLSD](https://github.com/cvg/DeepLSD), CVPR 2023
-- [x] [GlueStick](https://github.com/cvg/GlueStick), ICCV 2023
-- [ ] [ConvMatch](https://github.com/SuhZhang/ConvMatch), AAAI 2023
-- [x] [LoFTR](https://github.com/zju3dv/LoFTR), CVPR 2021
-- [x] [SOLD2](https://github.com/cvg/SOLD2), CVPR 2021
-- [ ] [LineTR](https://github.com/yosungho/LineTR), RA-L 2021
-- [x] [DKM](https://github.com/Parskatt/DKM), CVPR 2023
-- [ ] [NCMNet](https://github.com/xinliu29/NCMNet), CVPR 2023
-- [x] [TopicFM](https://github.com/Vincentqyw/TopicFM), AAAI 2023
-- [x] [AspanFormer](https://github.com/Vincentqyw/ml-aspanformer), ECCV 2022
-- [x] [LANet](https://github.com/wangch-g/lanet), ACCV 2022
-- [ ] [LISRD](https://github.com/rpautrat/LISRD), ECCV 2022
-- [ ] [REKD](https://github.com/bluedream1121/REKD), CVPR 2022
-- [x] [CoTR](https://github.com/ubc-vision/COTR), ICCV 2021
-- [x] [ALIKE](https://github.com/Shiaoming/ALIKE), TMM 2022
-- [x] [RoRD](https://github.com/UditSinghParihar/RoRD), IROS 2021
-- [x] [SGMNet](https://github.com/vdvchen/SGMNet), ICCV 2021
-- [x] [SuperPoint](https://github.com/magicleap/SuperPointPretrainedNetwork), CVPRW 2018
-- [x] [SuperGlue](https://github.com/magicleap/SuperGluePretrainedNetwork), CVPR 2020
-- [x] [D2Net](https://github.com/Vincentqyw/d2-net), CVPR 2019
-- [x] [R2D2](https://github.com/naver/r2d2), NeurIPS 2019
-- [x] [DISK](https://github.com/cvlab-epfl/disk), NeurIPS 2020
-- [ ] [Key.Net](https://github.com/axelBarroso/Key.Net), ICCV 2019
-- [ ] [OANet](https://github.com/zjhthu/OANet), ICCV 2019
-- [x] [SOSNet](https://github.com/scape-research/SOSNet), CVPR 2019
-- [x] [HardNet](https://github.com/DagnyT/hardnet), NeurIPS 2017
-- [x] [SIFT](https://docs.opencv.org/4.x/da/df5/tutorial_py_sift_intro.html), IJCV 2004
-
-## How to use
-
-### HuggingFace / Lightning AI
-
-Just try it on <a href='https://huggingface.co/spaces/Realcat/image-matching-webui'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue'></a> 
-<a target="_blank" href="https://lightning.ai/realcat/studios/image-matching-webui">
-  <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/app-2/studio-badge.svg" alt="Open In Studio"/>
-</a>
-
-or deploy it locally following the instructions below.
-
-### Requirements
-``` bash
-git clone --recursive https://github.com/Vincentqyw/image-matching-webui.git
-cd image-matching-webui
-conda env create -f environment.yaml
-conda activate imw
-```
-
-or using [docker](https://hub.docker.com/r/vincentqin/image-matching-webui):
-
-``` bash
-docker pull vincentqin/image-matching-webui:latest
-docker run -it -p 7860:7860 vincentqin/image-matching-webui:latest python app.py --server_name "0.0.0.0" --server_port=7860
-```
- 
-### Run demo
-``` bash
-python3 ./app.py
-```
-then open http://localhost:7860 in your browser.
-
-![](assets/gui.jpg)
-
-### Add your own feature / matcher
-
-I provide an example to add local feature in [hloc/extractors/example.py](hloc/extractors/example.py). Then add feature settings in `confs` in file [hloc/extract_features.py](hloc/extract_features.py). Last step is adding some settings to `model_zoo` in file [ui/config.yaml](ui/config.yaml).
-
-## Contributions welcome!
-
-External contributions are very much welcome. Please follow the [PEP8 style guidelines](https://www.python.org/dev/peps/pep-0008/) using a linter like flake8 (reformat using command `python -m black .`). This is a non-exhaustive list of features that might be valuable additions:
-
-- [x] add webcam support
-- [x] add [line feature matching](https://github.com/Vincentqyw/LineSegmentsDetection) algorithms
-- [x] example to add a new feature extractor / matcher
-- [x] ransac to filter outliers
-- [ ] add [rotation images](https://github.com/pidahbus/deep-image-orientation-angle-detection) options before matching 
-- [ ] support export matches to colmap ([#issue 6](https://github.com/Vincentqyw/image-matching-webui/issues/6))
-- [ ] add config file to set default parameters
-- [ ] dynamically load models and reduce GPU overload
-
-Adding local features / matchers as submodules is very easy. For example, to add the [GlueStick](https://github.com/cvg/GlueStick): 
-
-``` bash
-git submodule add https://github.com/cvg/GlueStick.git third_party/GlueStick
-```
-
-If remote submodule repositories are updated, don't forget to pull submodules with `git submodule update --remote`, if you only want to update one submodule, use `git submodule update --remote third_party/GlueStick`.
-
-## Resources
-- [Image Matching: Local Features & Beyond](https://image-matching-workshop.github.io)
-- [Long-term Visual Localization](https://www.visuallocalization.net)
-
-## Acknowledgement
-
-This code is built based on [Hierarchical-Localization](https://github.com/cvg/Hierarchical-Localization). We express our gratitude to the authors for their valuable source code.
-
-[contributors-shield]: https://img.shields.io/github/contributors/Vincentqyw/image-matching-webui.svg?style=for-the-badge
-[contributors-url]: https://github.com/Vincentqyw/image-matching-webui/graphs/contributors
-[forks-shield]: https://img.shields.io/github/forks/Vincentqyw/image-matching-webui.svg?style=for-the-badge
-[forks-url]: https://github.com/Vincentqyw/image-matching-webui/network/members
-[stars-shield]: https://img.shields.io/github/stars/Vincentqyw/image-matching-webui.svg?style=for-the-badge
-[stars-url]: https://github.com/Vincentqyw/image-matching-webui/stargazers
-[issues-shield]: https://img.shields.io/github/issues/Vincentqyw/image-matching-webui.svg?style=for-the-badge
-[issues-url]: https://github.com/Vincentqyw/image-matching-webui/issues

api/client.py

@@ -1,225 +0,0 @@
-import argparse
-import base64
-import os
-import pickle
-import time
-from typing import Dict, List
-
-import cv2
-import numpy as np
-import requests
-
-ENDPOINT = "http://127.0.0.1:8001"
-if "REMOTE_URL_RAILWAY" in os.environ:
-    ENDPOINT = os.environ["REMOTE_URL_RAILWAY"]
-
-print(f"API ENDPOINT: {ENDPOINT}")
-
-API_VERSION = f"{ENDPOINT}/version"
-API_URL_MATCH = f"{ENDPOINT}/v1/match"
-API_URL_EXTRACT = f"{ENDPOINT}/v1/extract"
-
-
-def read_image(path: str) -> str:
-    """
-    Read an image from a file, encode it as a JPEG and then as a base64 string.
-
-    Args:
-        path (str): The path to the image to read.
-
-    Returns:
-        str: The base64 encoded image.
-    """
-    # Read the image from the file
-    img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
-
-    # Encode the image as a png, NO COMPRESSION!!!
-    retval, buffer = cv2.imencode(".png", img)
-
-    # Encode the JPEG as a base64 string
-    b64img = base64.b64encode(buffer).decode("utf-8")
-
-    return b64img
-
-
-def do_api_requests(url=API_URL_EXTRACT, **kwargs):
-    """
-    Helper function to send an API request to the image matching service.
-
-    Args:
-        url (str): The URL of the API endpoint to use. Defaults to the
-            feature extraction endpoint.
-        **kwargs: Additional keyword arguments to pass to the API.
-
-    Returns:
-        List[Dict[str, np.ndarray]]: A list of dictionaries containing the
-            extracted features. The keys are "keypoints", "descriptors", and
-            "scores", and the values are ndarrays of shape (N, 2), (N, ?),
-            and (N,), respectively.
-    """
-    # Set up the request body
-    reqbody = {
-        # List of image data base64 encoded
-        "data": [],
-        # List of maximum number of keypoints to extract from each image
-        "max_keypoints": [100, 100],
-        # List of timestamps for each image (not used?)
-        "timestamps": ["0", "1"],
-        # Whether to convert the images to grayscale
-        "grayscale": 0,
-        # List of image height and width
-        "image_hw": [[640, 480], [320, 240]],
-        # Type of feature to extract
-        "feature_type": 0,
-        # List of rotation angles for each image
-        "rotates": [0.0, 0.0],
-        # List of scale factors for each image
-        "scales": [1.0, 1.0],
-        # List of reference points for each image (not used)
-        "reference_points": [[640, 480], [320, 240]],
-        # Whether to binarize the descriptors
-        "binarize": True,
-    }
-    # Update the request body with the additional keyword arguments
-    reqbody.update(kwargs)
-    try:
-        # Send the request
-        r = requests.post(url, json=reqbody)
-        if r.status_code == 200:
-            # Return the response
-            return r.json()
-        else:
-            # Print an error message if the response code is not 200
-            print(f"Error: Response code {r.status_code} - {r.text}")
-    except Exception as e:
-        # Print an error message if an exception occurs
-        print(f"An error occurred: {e}")
-
-
-def send_request_match(path0: str, path1: str) -> Dict[str, np.ndarray]:
-    """
-    Send a request to the API to generate a match between two images.
-
-    Args:
-        path0 (str): The path to the first image.
-        path1 (str): The path to the second image.
-
-    Returns:
-        Dict[str, np.ndarray]: A dictionary containing the generated matches.
-            The keys are "keypoints0", "keypoints1", "matches0", and "matches1",
-            and the values are ndarrays of shape (N, 2), (N, 2), (N, 2), and
-            (N, 2), respectively.
-    """
-    files = {"image0": open(path0, "rb"), "image1": open(path1, "rb")}
-    try:
-        # TODO: replace files with post json
-        response = requests.post(API_URL_MATCH, files=files)
-        pred = {}
-        if response.status_code == 200:
-            pred = response.json()
-            for key in list(pred.keys()):
-                pred[key] = np.array(pred[key])
-        else:
-            print(
-                f"Error: Response code {response.status_code} - {response.text}"
-            )
-    finally:
-        files["image0"].close()
-        files["image1"].close()
-    return pred
-
-
-def send_request_extract(
-    input_images: str, viz: bool = False
-) -> List[Dict[str, np.ndarray]]:
-    """
-    Send a request to the API to extract features from an image.
-
-    Args:
-        input_images (str): The path to the image.
-
-    Returns:
-        List[Dict[str, np.ndarray]]: A list of dictionaries containing the
-            extracted features. The keys are "keypoints", "descriptors", and
-            "scores", and the values are ndarrays of shape (N, 2), (N, 128),
-            and (N,), respectively.
-    """
-    image_data = read_image(input_images)
-    inputs = {
-        "data": [image_data],
-    }
-    response = do_api_requests(
-        url=API_URL_EXTRACT,
-        **inputs,
-    )
-    print("Keypoints detected: {}".format(len(response[0]["keypoints"])))
-
-    # draw matching, debug only
-    if viz:
-        from hloc.utils.viz import plot_keypoints
-        from ui.viz import fig2im, plot_images
-
-        kpts = np.array(response[0]["keypoints_orig"])
-        if "image_orig" in response[0].keys():
-            img_orig = np.array(["image_orig"])
-
-            output_keypoints = plot_images([img_orig], titles="titles", dpi=300)
-            plot_keypoints([kpts])
-            output_keypoints = fig2im(output_keypoints)
-            cv2.imwrite(
-                "demo_match.jpg",
-                output_keypoints[:, :, ::-1].copy(),  # RGB -> BGR
-            )
-    return response
-
-
-def get_api_version():
-    try:
-        response = requests.get(API_VERSION).json()
-        print("API VERSION: {}".format(response["version"]))
-    except Exception as e:
-        print(f"An error occurred: {e}")
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Send text to stable audio server and receive generated audio."
-    )
-    parser.add_argument(
-        "--image0",
-        required=False,
-        help="Path for the file's melody",
-        default="datasets/sacre_coeur/mapping_rot/02928139_3448003521_rot45.jpg",
-    )
-    parser.add_argument(
-        "--image1",
-        required=False,
-        help="Path for the file's melody",
-        default="datasets/sacre_coeur/mapping_rot/02928139_3448003521_rot90.jpg",
-    )
-    args = parser.parse_args()
-
-    # get api version
-    get_api_version()
-
-    # request match
-    # for i in range(10):
-    #     t1 = time.time()
-    #     preds = send_request_match(args.image0, args.image1)
-    #     t2 = time.time()
-    #     print(
-    #         "Time cost1: {} seconds, matched: {}".format(
-    #             (t2 - t1), len(preds["mmkeypoints0_orig"])
-    #         )
-    #     )
-
-    # request extract
-    for i in range(10):
-        t1 = time.time()
-        preds = send_request_extract(args.image0)
-        t2 = time.time()
-        print(f"Time cost2: {(t2 - t1)} seconds")
-
-    # dump preds
-    with open("preds.pkl", "wb") as f:
-        pickle.dump(preds, f)

api/server.py

@@ -1,499 +0,0 @@
-# server.py
-import base64
-import io
-import sys
-import warnings
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-import uvicorn
-from fastapi import FastAPI, File, UploadFile
-from fastapi.exceptions import HTTPException
-from fastapi.responses import JSONResponse
-from PIL import Image
-
-sys.path.append(str(Path(__file__).parents[1]))
-
-from api.types import ImagesInput
-from hloc import DEVICE, extract_features, logger, match_dense, match_features
-from hloc.utils.viz import add_text, plot_keypoints
-from ui import get_version
-from ui.utils import filter_matches, get_feature_model, get_model
-from ui.viz import display_matches, fig2im, plot_images
-
-warnings.simplefilter("ignore")
-
-
-def decode_base64_to_image(encoding):
-    if encoding.startswith("data:image/"):
-        encoding = encoding.split(";")[1].split(",")[1]
-    try:
-        image = Image.open(io.BytesIO(base64.b64decode(encoding)))
-        return image
-    except Exception as e:
-        logger.warning(f"API cannot decode image: {e}")
-        raise HTTPException(
-            status_code=500, detail="Invalid encoded image"
-        ) from e
-
-
-def to_base64_nparray(encoding: str) -> np.ndarray:
-    return np.array(decode_base64_to_image(encoding)).astype("uint8")
-
-
-class ImageMatchingAPI(torch.nn.Module):
-    default_conf = {
-        "ransac": {
-            "enable": True,
-            "estimator": "poselib",
-            "geometry": "homography",
-            "method": "RANSAC",
-            "reproj_threshold": 3,
-            "confidence": 0.9999,
-            "max_iter": 10000,
-        },
-    }
-
-    def __init__(
-        self,
-        conf: dict = {},
-        device: str = "cpu",
-        detect_threshold: float = 0.015,
-        max_keypoints: int = 1024,
-        match_threshold: float = 0.2,
-    ) -> None:
-        """
-        Initializes an instance of the ImageMatchingAPI class.
-
-        Args:
-            conf (dict): A dictionary containing the configuration parameters.
-            device (str, optional): The device to use for computation. Defaults to "cpu".
-            detect_threshold (float, optional): The threshold for detecting keypoints. Defaults to 0.015.
-            max_keypoints (int, optional): The maximum number of keypoints to extract. Defaults to 1024.
-            match_threshold (float, optional): The threshold for matching keypoints. Defaults to 0.2.
-
-        Returns:
-            None
-        """
-        super().__init__()
-        self.device = device
-        self.conf = {**self.default_conf, **conf}
-        self._updata_config(detect_threshold, max_keypoints, match_threshold)
-        self._init_models()
-        if device == "cuda":
-            memory_allocated = torch.cuda.memory_allocated(device)
-            memory_reserved = torch.cuda.memory_reserved(device)
-            logger.info(
-                f"GPU memory allocated: {memory_allocated / 1024**2:.3f} MB"
-            )
-            logger.info(
-                f"GPU memory reserved: {memory_reserved / 1024**2:.3f} MB"
-            )
-        self.pred = None
-
-    def parse_match_config(self, conf):
-        if conf["dense"]:
-            return {
-                **conf,
-                "matcher": match_dense.confs.get(
-                    conf["matcher"]["model"]["name"]
-                ),
-                "dense": True,
-            }
-        else:
-            return {
-                **conf,
-                "feature": extract_features.confs.get(
-                    conf["feature"]["model"]["name"]
-                ),
-                "matcher": match_features.confs.get(
-                    conf["matcher"]["model"]["name"]
-                ),
-                "dense": False,
-            }
-
-    def _updata_config(
-        self,
-        detect_threshold: float = 0.015,
-        max_keypoints: int = 1024,
-        match_threshold: float = 0.2,
-    ):
-        self.dense = self.conf["dense"]
-        if self.conf["dense"]:
-            try:
-                self.conf["matcher"]["model"][
-                    "match_threshold"
-                ] = match_threshold
-            except TypeError as e:
-                logger.error(e)
-        else:
-            self.conf["feature"]["model"]["max_keypoints"] = max_keypoints
-            self.conf["feature"]["model"][
-                "keypoint_threshold"
-            ] = detect_threshold
-            self.extract_conf = self.conf["feature"]
-
-        self.match_conf = self.conf["matcher"]
-
-    def _init_models(self):
-        # initialize matcher
-        self.matcher = get_model(self.match_conf)
-        # initialize extractor
-        if self.dense:
-            self.extractor = None
-        else:
-            self.extractor = get_feature_model(self.conf["feature"])
-
-    def _forward(self, img0, img1):
-        if self.dense:
-            pred = match_dense.match_images(
-                self.matcher,
-                img0,
-                img1,
-                self.match_conf["preprocessing"],
-                device=self.device,
-            )
-            last_fixed = "{}".format(  # noqa: F841
-                self.match_conf["model"]["name"]
-            )
-        else:
-            pred0 = extract_features.extract(
-                self.extractor, img0, self.extract_conf["preprocessing"]
-            )
-            pred1 = extract_features.extract(
-                self.extractor, img1, self.extract_conf["preprocessing"]
-            )
-            pred = match_features.match_images(self.matcher, pred0, pred1)
-        return pred
-
-    @torch.inference_mode()
-    def extract(self, img0: np.ndarray, **kwargs) -> Dict[str, np.ndarray]:
-        """Extract features from a single image.
-
-        Args:
-            img0 (np.ndarray): image
-
-        Returns:
-            Dict[str, np.ndarray]: feature dict
-        """
-
-        # setting prams
-        self.extractor.conf["max_keypoints"] = kwargs.get("max_keypoints", 512)
-        self.extractor.conf["keypoint_threshold"] = kwargs.get(
-            "keypoint_threshold", 0.0
-        )
-
-        pred = extract_features.extract(
-            self.extractor, img0, self.extract_conf["preprocessing"]
-        )
-        pred = {
-            k: v.cpu().detach()[0].numpy() if isinstance(v, torch.Tensor) else v
-            for k, v in pred.items()
-        }
-        # back to origin scale
-        s0 = pred["original_size"] / pred["size"]
-        pred["keypoints_orig"] = (
-            match_features.scale_keypoints(pred["keypoints"] + 0.5, s0) - 0.5
-        )
-        # TODO: rotate back
-
-        binarize = kwargs.get("binarize", False)
-        if binarize:
-            assert "descriptors" in pred
-            pred["descriptors"] = (pred["descriptors"] > 0).astype(np.uint8)
-            pred["descriptors"] = pred["descriptors"].T  # N x DIM
-        return pred
-
-    @torch.inference_mode()
-    def forward(
-        self,
-        img0: np.ndarray,
-        img1: np.ndarray,
-    ) -> Dict[str, np.ndarray]:
-        """
-        Forward pass of the image matching API.
-
-        Args:
-            img0: A 3D NumPy array of shape (H, W, C) representing the first image.
-                  Values are in the range [0, 1] and are in RGB mode.
-            img1: A 3D NumPy array of shape (H, W, C) representing the second image.
-                  Values are in the range [0, 1] and are in RGB mode.
-
-        Returns:
-            A dictionary containing the following keys:
-            - image0_orig: The original image 0.
-            - image1_orig: The original image 1.
-            - keypoints0_orig: The keypoints detected in image 0.
-            - keypoints1_orig: The keypoints detected in image 1.
-            - mkeypoints0_orig: The raw matches between image 0 and image 1.
-            - mkeypoints1_orig: The raw matches between image 1 and image 0.
-            - mmkeypoints0_orig: The RANSAC inliers in image 0.
-            - mmkeypoints1_orig: The RANSAC inliers in image 1.
-            - mconf: The confidence scores for the raw matches.
-            - mmconf: The confidence scores for the RANSAC inliers.
-        """
-        # Take as input a pair of images (not a batch)
-        assert isinstance(img0, np.ndarray)
-        assert isinstance(img1, np.ndarray)
-        self.pred = self._forward(img0, img1)
-        if self.conf["ransac"]["enable"]:
-            self.pred = self._geometry_check(self.pred)
-        return self.pred
-
-    def _geometry_check(
-        self,
-        pred: Dict[str, Any],
-    ) -> Dict[str, Any]:
-        """
-        Filter matches using RANSAC. If keypoints are available, filter by keypoints.
-        If lines are available, filter by lines. If both keypoints and lines are
-        available, filter by keypoints.
-
-        Args:
-            pred (Dict[str, Any]): dict of matches, including original keypoints.
-                                  See :func:`filter_matches` for the expected keys.
-
-        Returns:
-            Dict[str, Any]: filtered matches
-        """
-        pred = filter_matches(
-            pred,
-            ransac_method=self.conf["ransac"]["method"],
-            ransac_reproj_threshold=self.conf["ransac"]["reproj_threshold"],
-            ransac_confidence=self.conf["ransac"]["confidence"],
-            ransac_max_iter=self.conf["ransac"]["max_iter"],
-        )
-        return pred
-
-    def visualize(
-        self,
-        log_path: Optional[Path] = None,
-    ) -> None:
-        """
-        Visualize the matches.
-
-        Args:
-            log_path (Path, optional): The directory to save the images. Defaults to None.
-
-        Returns:
-            None
-        """
-        if self.conf["dense"]:
-            postfix = str(self.conf["matcher"]["model"]["name"])
-        else:
-            postfix = "{}_{}".format(
-                str(self.conf["feature"]["model"]["name"]),
-                str(self.conf["matcher"]["model"]["name"]),
-            )
-        titles = [
-            "Image 0 - Keypoints",
-            "Image 1 - Keypoints",
-        ]
-        pred: Dict[str, Any] = self.pred
-        image0: np.ndarray = pred["image0_orig"]
-        image1: np.ndarray = pred["image1_orig"]
-        output_keypoints: np.ndarray = plot_images(
-            [image0, image1], titles=titles, dpi=300
-        )
-        if (
-            "keypoints0_orig" in pred.keys()
-            and "keypoints1_orig" in pred.keys()
-        ):
-            plot_keypoints([pred["keypoints0_orig"], pred["keypoints1_orig"]])
-            text: str = (
-                f"# keypoints0: {len(pred['keypoints0_orig'])} \n"
-                + f"# keypoints1: {len(pred['keypoints1_orig'])}"
-            )
-            add_text(0, text, fs=15)
-        output_keypoints = fig2im(output_keypoints)
-        # plot images with raw matches
-        titles = [
-            "Image 0 - Raw matched keypoints",
-            "Image 1 - Raw matched keypoints",
-        ]
-        output_matches_raw, num_matches_raw = display_matches(
-            pred, titles=titles, tag="KPTS_RAW"
-        )
-        # plot images with ransac matches
-        titles = [
-            "Image 0 - Ransac matched keypoints",
-            "Image 1 - Ransac matched keypoints",
-        ]
-        output_matches_ransac, num_matches_ransac = display_matches(
-            pred, titles=titles, tag="KPTS_RANSAC"
-        )
-        if log_path is not None:
-            img_keypoints_path: Path = log_path / f"img_keypoints_{postfix}.png"
-            img_matches_raw_path: Path = (
-                log_path / f"img_matches_raw_{postfix}.png"
-            )
-            img_matches_ransac_path: Path = (
-                log_path / f"img_matches_ransac_{postfix}.png"
-            )
-            cv2.imwrite(
-                str(img_keypoints_path),
-                output_keypoints[:, :, ::-1].copy(),  # RGB -> BGR
-            )
-            cv2.imwrite(
-                str(img_matches_raw_path),
-                output_matches_raw[:, :, ::-1].copy(),  # RGB -> BGR
-            )
-            cv2.imwrite(
-                str(img_matches_ransac_path),
-                output_matches_ransac[:, :, ::-1].copy(),  # RGB -> BGR
-            )
-            plt.close("all")
-
-
-class ImageMatchingService:
-    def __init__(self, conf: dict, device: str):
-        self.conf = conf
-        self.api = ImageMatchingAPI(conf=conf, device=device)
-        self.app = FastAPI()
-        self.register_routes()
-
-    def register_routes(self):
-
-        @self.app.get("/version")
-        async def version():
-            return {"version": get_version()}
-
-        @self.app.post("/v1/match")
-        async def match(
-            image0: UploadFile = File(...), image1: UploadFile = File(...)
-        ):
-            """
-            Handle the image matching request and return the processed result.
-
-            Args:
-                image0 (UploadFile): The first image file for matching.
-                image1 (UploadFile): The second image file for matching.
-
-            Returns:
-                JSONResponse: A JSON response containing the filtered match results
-                              or an error message in case of failure.
-            """
-            try:
-                # Load the images from the uploaded files
-                image0_array = self.load_image(image0)
-                image1_array = self.load_image(image1)
-
-                # Perform image matching using the API
-                output = self.api(image0_array, image1_array)
-
-                # Keys to skip in the output
-                skip_keys = ["image0_orig", "image1_orig"]
-
-                # Postprocess the output to filter unwanted data
-                pred = self.postprocess(output, skip_keys)
-
-                # Return the filtered prediction as a JSON response
-                return JSONResponse(content=pred)
-            except Exception as e:
-                # Return an error message with status code 500 in case of exception
-                return JSONResponse(content={"error": str(e)}, status_code=500)
-
-        @self.app.post("/v1/extract")
-        async def extract(input_info: ImagesInput):
-            """
-            Extract keypoints and descriptors from images.
-
-            Args:
-                input_info: An object containing the image data and options.
-
-            Returns:
-                A list of dictionaries containing the keypoints and descriptors.
-            """
-            try:
-                preds = []
-                for i, input_image in enumerate(input_info.data):
-                    # Load the image from the input data
-                    image_array = to_base64_nparray(input_image)
-                    # Extract keypoints and descriptors
-                    output = self.api.extract(
-                        image_array,
-                        max_keypoints=input_info.max_keypoints[i],
-                        binarize=input_info.binarize,
-                    )
-                    # Do not return the original image and image_orig
-                    # skip_keys = ["image", "image_orig"]
-                    skip_keys = []
-
-                    # Postprocess the output
-                    pred = self.postprocess(output, skip_keys)
-                    preds.append(pred)
-                # Return the list of extracted features
-                return JSONResponse(content=preds)
-            except Exception as e:
-                # Return an error message if an exception occurs
-                return JSONResponse(content={"error": str(e)}, status_code=500)
-
-    def load_image(self, file_path: Union[str, UploadFile]) -> np.ndarray:
-        """
-        Reads an image from a file path or an UploadFile object.
-
-        Args:
-            file_path: A file path or an UploadFile object.
-
-        Returns:
-            A numpy array representing the image.
-        """
-        if isinstance(file_path, str):
-            file_path = Path(file_path).resolve(strict=False)
-        else:
-            file_path = file_path.file
-        with Image.open(file_path) as img:
-            image_array = np.array(img)
-        return image_array
-
-    def postprocess(
-        self, output: dict, skip_keys: list, binarize: bool = True
-    ) -> dict:
-        pred = {}
-        for key, value in output.items():
-            if key in skip_keys:
-                continue
-            if isinstance(value, np.ndarray):
-                pred[key] = value.tolist()
-        return pred
-
-    def run(self, host: str = "0.0.0.0", port: int = 8001):
-        uvicorn.run(self.app, host=host, port=port)
-
-
-if __name__ == "__main__":
-    conf = {
-        "feature": {
-            "output": "feats-superpoint-n4096-rmax1600",
-            "model": {
-                "name": "superpoint",
-                "nms_radius": 3,
-                "max_keypoints": 4096,
-                "keypoint_threshold": 0.005,
-            },
-            "preprocessing": {
-                "grayscale": True,
-                "force_resize": True,
-                "resize_max": 1600,
-                "width": 640,
-                "height": 480,
-                "dfactor": 8,
-            },
-        },
-        "matcher": {
-            "output": "matches-NN-mutual",
-            "model": {
-                "name": "nearest_neighbor",
-                "do_mutual_check": True,
-                "match_threshold": 0.2,
-            },
-        },
-        "dense": False,
-    }
-
-    service = ImageMatchingService(conf=conf, device=DEVICE)
-    service.run()

api/test/CMakeLists.txt

@@ -1,16 +0,0 @@
-cmake_minimum_required(VERSION 3.10)
-project(imatchui)
-
-set(OpenCV_DIR /usr/include/opencv4)
-find_package(OpenCV REQUIRED)
-
-find_package(Boost REQUIRED COMPONENTS system)
-if(Boost_FOUND)
-    include_directories(${Boost_INCLUDE_DIRS})
-endif()
-
-add_executable(client client.cpp)
-
-target_include_directories(client PRIVATE ${Boost_LIBRARIES} ${OpenCV_INCLUDE_DIRS})
-
-target_link_libraries(client PRIVATE curl jsoncpp b64 ${OpenCV_LIBS})

api/test/build_and_run.sh

@@ -1,16 +0,0 @@
-# g++ main.cpp -I/usr/include/opencv4 -lcurl -ljsoncpp -lb64 -lopencv_core -lopencv_imgcodecs -o main
-# sudo apt-get update
-# sudo apt-get install libboost-all-dev -y
-# sudo apt-get install libcurl4-openssl-dev libjsoncpp-dev libb64-dev libopencv-dev -y
-
-cd build
-cmake ..
-make -j12
-
-echo " ======== RUN DEMO ========"
-
-./client
-
-echo " ======== END DEMO ========"
-
-cd ..

api/test/client.cpp

@@ -1,84 +0,0 @@
-#include <curl/curl.h>
-#include <opencv2/opencv.hpp>
-#include "helper.h"
-
-int main() {
-    std::string img_path = "../../../datasets/sacre_coeur/mapping_rot/02928139_3448003521_rot45.jpg";
-    cv::Mat original_img = cv::imread(img_path, cv::IMREAD_GRAYSCALE);
-
-    if (original_img.empty()) {
-        throw std::runtime_error("Failed to decode image");
-    }
-
-    // Convert the image to Base64
-    std::string base64_img = image_to_base64(original_img);
-
-    // Convert the Base64 back to an image
-    cv::Mat decoded_img = base64_to_image(base64_img);
-    cv::imwrite("decoded_image.jpg", decoded_img);
-    cv::imwrite("original_img.jpg", original_img);
-
-    // The images should be identical
-    if (cv::countNonZero(original_img != decoded_img) != 0) {
-        std::cerr << "The images are not identical" << std::endl;
-        return -1;
-    } else {
-        std::cout << "The images are identical!" << std::endl;
-    }
-
-    // construct params
-    APIParams params{
-        .data = {base64_img},
-        .max_keypoints = {100, 100},
-        .timestamps = {"0", "1"},
-        .grayscale = {0},
-        .image_hw = {{480, 640}, {240, 320}},
-        .feature_type = 0,
-        .rotates = {0.0f, 0.0f},
-        .scales = {1.0f, 1.0f},
-        .reference_points = {
-            {1.23e+2f, 1.2e+1f},
-            {5.0e-1f, 3.0e-1f},
-            {2.3e+2f, 2.2e+1f},
-            {6.0e-1f, 4.0e-1f}
-        },
-        .binarize = {1}
-    };
-
-    KeyPointResults kpts_results;
-
-    // Convert the parameters to JSON
-    Json::Value jsonData = paramsToJson(params);
-    std::string url = "http://127.0.0.1:8001/v1/extract";
-    Json::StreamWriterBuilder writer;
-    std::string output = Json::writeString(writer, jsonData);
-
-    CURL* curl;
-    CURLcode res;
-    std::string readBuffer;
-
-    curl_global_init(CURL_GLOBAL_DEFAULT);
-    curl = curl_easy_init();
-    if (curl) {
-        struct curl_slist* hs = NULL;
-        hs = curl_slist_append(hs, "Content-Type: application/json");
-        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, hs);
-        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, output.c_str());
-        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
-        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
-        res = curl_easy_perform(curl);
-
-        if (res != CURLE_OK)
-            fprintf(stderr, "curl_easy_perform() failed: %s\n",
-                    curl_easy_strerror(res));
-        else {
-            // std::cout << "Response from server: " << readBuffer << std::endl;
-           kpts_results =  decode_response(readBuffer);
-        }
-        curl_easy_cleanup(curl);
-    }
-    curl_global_cleanup();
-
-    return 0;
-}

api/test/helper.h

@@ -1,410 +0,0 @@
-
-#include <sstream>
-#include <fstream>
-#include <vector>
-#include <b64/encode.h>
-#include <jsoncpp/json/json.h>
-#include <opencv2/opencv.hpp>
-
-// base64 to image
-#include <boost/archive/iterators/binary_from_base64.hpp>
-#include <boost/archive/iterators/transform_width.hpp>
-#include <boost/archive/iterators/base64_from_binary.hpp>
-
-/// Parameters used in the API
-struct APIParams {
-    /// A list of images, base64 encoded
-    std::vector<std::string> data;
-
-    /// The maximum number of keypoints to detect for each image
-    std::vector<int> max_keypoints;
-
-    /// The timestamps of the images
-    std::vector<std::string> timestamps;
-
-    /// Whether to convert the images to grayscale
-    bool grayscale;
-
-    /// The height and width of each image
-    std::vector<std::vector<int>> image_hw;
-
-    /// The type of feature detector to use
-    int feature_type;
-
-    /// The rotations of the images
-    std::vector<double> rotates;
-
-    /// The scales of the images
-    std::vector<double> scales;
-
-    /// The reference points of the images
-    std::vector<std::vector<float>> reference_points;
-
-    /// Whether to binarize the descriptors
-    bool binarize;
-};
-
-/**
- * @brief Contains the results of a keypoint detector.
- *
- * @details Stores the keypoints and descriptors for each image.
- */
-class KeyPointResults {
-public:
-    KeyPointResults() {}
-
-    /**
-     * @brief Constructor.
-     *
-     * @param kp The keypoints for each image.
-     */
-    KeyPointResults(const std::vector<std::vector<cv::KeyPoint>>& kp, 
-                    const std::vector<cv::Mat>& desc)
-        : keypoints(kp), descriptors(desc) {}
-
-    /**
-     * @brief Append keypoints to the result.
-     *
-     * @param kpts The keypoints to append.
-     */
-    inline void append_keypoints(std::vector<cv::KeyPoint>& kpts) {
-        keypoints.emplace_back(kpts);
-    }
-
-    /**
-     * @brief Append descriptors to the result.
-     *
-     * @param desc The descriptors to append.
-     */
-    inline void append_descriptors(cv::Mat& desc) {
-        descriptors.emplace_back(desc);
-    }
-
-    /**
-     * @brief Get the keypoints.
-     *
-     * @return The keypoints.
-     */
-    inline std::vector<std::vector<cv::KeyPoint>> get_keypoints() {
-        return keypoints;
-    }
-
-    /**
-     * @brief Get the descriptors.
-     *
-     * @return The descriptors.
-     */
-    inline std::vector<cv::Mat> get_descriptors() {
-        return descriptors;
-    }
-
-private:
-    std::vector<std::vector<cv::KeyPoint>> keypoints;
-    std::vector<cv::Mat> descriptors;
-    std::vector<std::vector<float>> scores;
-};
-
-
-/**
- * @brief Decodes a base64 encoded string.
- *
- * @param base64 The base64 encoded string to decode.
- * @return The decoded string.
- */
-std::string base64_decode(const std::string& base64) {
-    using namespace boost::archive::iterators;
-    using It = transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;
-
-    // Find the position of the last non-whitespace character
-    auto end = base64.find_last_not_of(" \t\n\r");
-    if (end != std::string::npos) {
-        // Move one past the last non-whitespace character
-        end += 1;
-    }
-
-    // Decode the base64 string and return the result
-    return std::string(It(base64.begin()), It(base64.begin() + end));
-}
-
-
-
-/**
- * @brief Decodes a base64 string into an OpenCV image
- *
- * @param base64 The base64 encoded string
- * @return The decoded OpenCV image
- */
-cv::Mat base64_to_image(const std::string& base64) {
-    // Decode the base64 string
-    std::string decodedStr = base64_decode(base64);
-
-    // Decode the image
-    std::vector<uchar> data(decodedStr.begin(), decodedStr.end());
-    cv::Mat img = cv::imdecode(data, cv::IMREAD_GRAYSCALE);
-
-    // Check for errors
-    if (img.empty()) {
-        throw std::runtime_error("Failed to decode image");
-    }
-
-    return img;
-}
-
-
-/**
- * @brief Encodes an OpenCV image into a base64 string
- *
- * This function takes an OpenCV image and encodes it into a base64 string.
- * The image is first encoded as a PNG image, and then the resulting
- * bytes are encoded as a base64 string.
- *
- * @param img The OpenCV image
- * @return The base64 encoded string
- *
- * @throws std::runtime_error if the image is empty or encoding fails
- */
-std::string image_to_base64(cv::Mat &img) {
-    if (img.empty()) {
-        throw std::runtime_error("Failed to read image");
-    }
-
-    // Encode the image as a PNG
-    std::vector<uchar> buf;
-    if (!cv::imencode(".png", img, buf)) {
-        throw std::runtime_error("Failed to encode image");
-    }
-
-    // Encode the bytes as a base64 string
-    using namespace boost::archive::iterators;
-    using It = base64_from_binary<transform_width<std::vector<uchar>::const_iterator, 6, 8>>;
-    std::string base64(It(buf.begin()), It(buf.end()));
-
-    // Pad the string with '=' characters to a multiple of 4 bytes
-    base64.append((3 - buf.size() % 3) % 3, '=');
-
-    return base64;
-}
-
-
-/**
- * @brief Callback function for libcurl to write data to a string
- *
- * This function is used as a callback for libcurl to write data to a string.
- * It takes the contents, size, and nmemb as parameters, and writes the data to
- * the string.
- *
- * @param contents The data to write
- * @param size The size of the data
- * @param nmemb The number of members in the data
- * @param s The string to write the data to
- * @return The number of bytes written
- */
-size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
-    size_t newLength = size * nmemb;
-    try {
-        // Resize the string to fit the new data
-        s->resize(s->size() + newLength);
-    } catch (std::bad_alloc& e) {
-        // If there's an error allocating memory, return 0
-        return 0;
-    }
-
-    // Copy the data to the string
-    std::copy(static_cast<const char*>(contents),
-              static_cast<const char*>(contents) + newLength,
-              s->begin() + s->size() - newLength);
-    return newLength;
-}
-
-// Helper functions
-
-/**
- * @brief Helper function to convert a type to a Json::Value
- *
- * This function takes a value of type T and converts it to a Json::Value.
- * It is used to simplify the process of converting a type to a Json::Value.
- *
- * @param val The value to convert
- * @return The converted Json::Value
- */
-template <typename T>
-Json::Value toJson(const T& val) {
-    return Json::Value(val);
-}
-
-/**
- * @brief Converts a vector to a Json::Value
- *
- * This function takes a vector of type T and converts it to a Json::Value.
- * Each element in the vector is appended to the Json::Value array.
- *
- * @param vec The vector to convert to Json::Value
- * @return The Json::Value representing the vector
- */
-template <typename T>
-Json::Value vectorToJson(const std::vector<T>& vec) {
-    Json::Value json(Json::arrayValue);
-    for (const auto& item : vec) {
-        json.append(item);
-    }
-    return json;
-}
-
-/**
- * @brief Converts a nested vector to a Json::Value
- *
- * This function takes a nested vector of type T and converts it to a Json::Value.
- * Each sub-vector is converted to a Json::Value array and appended to the main Json::Value array.
- *
- * @param vec The nested vector to convert to Json::Value
- * @return The Json::Value representing the nested vector
- */
-template <typename T>
-Json::Value nestedVectorToJson(const std::vector<std::vector<T>>& vec) {
-    Json::Value json(Json::arrayValue);
-    for (const auto& subVec : vec) {
-        json.append(vectorToJson(subVec));
-    }
-    return json;
-}
-
-
-
-/**
- * @brief Converts the APIParams struct to a Json::Value
- *
- * This function takes an APIParams struct and converts it to a Json::Value.
- * The Json::Value is a JSON object with the following fields:
- * - data: a JSON array of base64 encoded images
- * - max_keypoints: a JSON array of integers, max number of keypoints for each image
- * - timestamps: a JSON array of timestamps, one for each image
- * - grayscale: a JSON boolean, whether to convert images to grayscale
- * - image_hw: a nested JSON array, each sub-array contains the height and width of an image
- * - feature_type: a JSON integer, the type of feature detector to use
- * - rotates: a JSON array of doubles, the rotation of each image
- * - scales: a JSON array of doubles, the scale of each image
- * - reference_points: a nested JSON array, each sub-array contains the reference points of an image
- * - binarize: a JSON boolean, whether to binarize the descriptors
- *
- * @param params The APIParams struct to convert
- * @return The Json::Value representing the APIParams struct
- */
-Json::Value paramsToJson(const APIParams& params) {
-    Json::Value json;
-    json["data"] = vectorToJson(params.data);
-    json["max_keypoints"] = vectorToJson(params.max_keypoints);
-    json["timestamps"] = vectorToJson(params.timestamps);
-    json["grayscale"] = toJson(params.grayscale);
-    json["image_hw"] = nestedVectorToJson(params.image_hw);
-    json["feature_type"] = toJson(params.feature_type);
-    json["rotates"] = vectorToJson(params.rotates);
-    json["scales"] = vectorToJson(params.scales);
-    json["reference_points"] = nestedVectorToJson(params.reference_points);
-    json["binarize"] = toJson(params.binarize);
-    return json;
-}
-
-template<typename T>
-cv::Mat jsonToMat(Json::Value json) {
-    int rows = json.size();
-    int cols = json[0].size();
-
-    // Create a single array to hold all the data.
-    std::vector<T> data;
-    data.reserve(rows * cols);
-
-    for (int i = 0; i < rows; i++) {
-        for (int j = 0; j < cols; j++) {
-            data.push_back(static_cast<T>(json[i][j].asInt()));
-        }
-    }
-
-    // Create a cv::Mat object that points to the data.
-    cv::Mat mat(rows, cols, CV_8UC1, data.data());  // Change the type if necessary.
-    // cv::Mat mat(cols, rows,CV_8UC1, data.data());  // Change the type if necessary.
-
-    return mat;
-}
-
-
-
-/**
- * @brief Decodes the response of the server and prints the keypoints
- *
- * This function takes the response of the server, a JSON string, and decodes
- * it. It then prints the keypoints and draws them on the original image.
- *
- * @param response The response of the server
- * @return The keypoints and descriptors
- */
-KeyPointResults decode_response(const std::string& response, bool viz=true) {
-    Json::CharReaderBuilder builder;
-    Json::CharReader* reader = builder.newCharReader();
-
-    Json::Value jsonData;
-    std::string errors;
-
-    // Parse the JSON response
-    bool parsingSuccessful = reader->parse(response.c_str(),
-        response.c_str() + response.size(), &jsonData, &errors);
-    delete reader;
-
-    if (!parsingSuccessful) {
-        // Handle error
-        std::cout << "Failed to parse the JSON, errors:" << std::endl;
-        std::cout << errors << std::endl;
-        return KeyPointResults();
-    }
-
-    KeyPointResults kpts_results;
-
-    // Iterate over the images
-    for (const auto& jsonItem : jsonData) {
-        auto jkeypoints = jsonItem["keypoints"];
-        auto jkeypoints_orig = jsonItem["keypoints_orig"];
-        auto jdescriptors = jsonItem["descriptors"];
-        auto jscores = jsonItem["scores"];
-        auto jimageSize = jsonItem["image_size"];
-        auto joriginalSize = jsonItem["original_size"];
-        auto jsize = jsonItem["size"];
-
-        std::vector<cv::KeyPoint> vkeypoints;
-        std::vector<float> vscores;
-
-        // Iterate over the keypoints
-        int counter = 0;
-        for (const auto& keypoint : jkeypoints_orig) {
-            if (counter < 10) {
-                // Print the first 10 keypoints
-                std::cout << keypoint[0].asFloat() << ", "
-                    << keypoint[1].asFloat() << std::endl;
-            }
-            counter++;
-            // Convert the Json::Value to a cv::KeyPoint
-            vkeypoints.emplace_back(cv::KeyPoint(keypoint[0].asFloat(),
-                keypoint[1].asFloat(), 0.0));
-        }
-
-        if (viz && jsonItem.isMember("image_orig")) {
-
-            auto jimg_orig = jsonItem["image_orig"];
-            cv::Mat img = jsonToMat<uchar>(jimg_orig);
-            cv::imwrite("viz_image_orig.jpg", img);
-
-            // Draw keypoints on the image
-            cv::Mat imgWithKeypoints;
-            cv::drawKeypoints(img, vkeypoints, 
-                imgWithKeypoints, cv::Scalar(0, 0, 255));
-
-            // Write the image with keypoints
-            std::string filename = "viz_image_orig_keypoints.jpg";
-            cv::imwrite(filename, imgWithKeypoints);
-        }
-
-        // Iterate over the descriptors
-        cv::Mat descriptors = jsonToMat<uchar>(jdescriptors); 
-        kpts_results.append_keypoints(vkeypoints);
-        kpts_results.append_descriptors(descriptors);
-    }
-    return kpts_results;
-}

api/types.py

@@ -1,16 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-
-
-class ImagesInput(BaseModel):
-    data: List[str] = []
-    max_keypoints: List[int] = []
-    timestamps: List[str] = []
-    grayscale: bool = False
-    image_hw: List[List[int]] = [[], []]
-    feature_type: int = 0
-    rotates: List[float] = []
-    scales: List[float] = []
-    reference_points: List[List[float]] = []
-    binarize: bool = False

app.py

@@ -1,6 +1,6 @@
 import argparse
 from pathlib import Path
-from ui.app_class import ImageMatchingApp
+from imcui.ui.app_class import ImageMatchingApp
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -19,10 +19,8 @@ if __name__ == "__main__":
     parser.add_argument(
         "--config",
         type=str,
-        default=Path(__file__).parent / "ui/config.yaml",
+        default=Path(__file__).parent / "config/config.yaml",
         help="config file",
     )
     args = parser.parse_args()
-    ImageMatchingApp(
-        args.server_name, args.server_port, config=args.config
-    ).run()
+    ImageMatchingApp(args.server_name, args.server_port, config=args.config).run()

build_docker.sh

@@ -1,3 +0,0 @@
-docker build -t image-matching-webui:latest . --no-cache
-docker tag image-matching-webui:latest vincentqin/image-matching-webui:latest
-docker push vincentqin/image-matching-webui:latest

{ui → config}/config.yaml

@@ -39,7 +39,7 @@ matcher_zoo:
       project: https://dust3r.europe.naverlabs.com
       display: true
   DUSt3R:
-    # TODO: duster is under development  
+    # TODO: duster is under development
     enable: true
     # skip_ci: true
     matcher: duster

datasets/sacre_coeur/README.md

@@ -1,3 +0,0 @@
-# Sacre Coeur demo
-
-We provide here a subset of images depicting the Sacre Coeur. These images were obtained from the [Image Matching Challenge 2021](https://www.cs.ubc.ca/research/image-matching-challenge/2021/data/) and were originally collected by the [Yahoo Flickr Creative Commons 100M (YFCC) dataset](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/).