update: interface

app.py

@@ -1,385 +1,6 @@
 import argparse
 from pathlib import Path
-import numpy as np
-from typing import Dict, Any, Optional, Tuple, List, Union
-import gradio as gr
-from common.utils import (
-    matcher_zoo,
-    ransac_zoo,
-    change_estimate_geom,
-    run_matching,
-    gen_examples,
-    GRADIO_VERSION,
-    DEFAULT_RANSAC_METHOD,
-    DEFAULT_SETTING_GEOMETRY,
-    DEFAULT_RANSAC_REPROJ_THRESHOLD,
-    DEFAULT_RANSAC_CONFIDENCE,
-    DEFAULT_RANSAC_MAX_ITER,
-    DEFAULT_MATCHING_THRESHOLD,
-    DEFAULT_SETTING_MAX_FEATURES,
-    DEFAULT_DEFAULT_KEYPOINT_THRESHOLD,
-)
-
-DESCRIPTION = """
-# Image Matching WebUI
-This Space demonstrates [Image Matching WebUI](https://github.com/Vincentqyw/image-matching-webui) by vincent qin. Feel free to play with it, or duplicate to run image matching without a queue!
-<br/>
-🔎 For more details about supported local features and matchers, please refer to https://github.com/Vincentqyw/image-matching-webui
-
-🚀 All algorithms run on CPU for inference, causing slow speeds and high latency. For faster inference, please download the [source code](https://github.com/Vincentqyw/image-matching-webui) for local deployment.
-
-🐛 Your feedback is valuable to me. Please do not hesitate to report any bugs [here](https://github.com/Vincentqyw/image-matching-webui/issues).
-"""
-
-
-def ui_change_imagebox(choice):
-    """
-    Updates the image box with the given choice.
-
-    Args:
-        choice (list): The list of image sources to be displayed in the image box.
-
-    Returns:
-        dict: A dictionary containing the updated value, sources, and type for the image box.
-    """
-    ret_dict = {
-        "value": None,  # The updated value of the image box
-        "__type__": "update",  # The type of update for the image box
-    }
-    if GRADIO_VERSION > "3":
-        return {
-            **ret_dict,
-            "sources": choice,  # The list of image sources to be displayed
-        }
-    else:
-        return {
-            **ret_dict,
-            "source": choice,  # The list of image sources to be displayed
-        }
-
-
-def ui_reset_state(
-    *args: Any,
-) -> Tuple[
-    Optional[np.ndarray],
-    Optional[np.ndarray],
-    float,
-    int,
-    float,
-    str,
-    Dict[str, Any],
-    Dict[str, Any],
-    str,
-    Optional[np.ndarray],
-    Optional[np.ndarray],
-    Optional[np.ndarray],
-    Dict[str, Any],
-    Dict[str, Any],
-    Optional[np.ndarray],
-    Dict[str, Any],
-    str,
-    int,
-    float,
-    int,
-]:
-    """
-    Reset the state of the UI.
-
-    Returns:
-        tuple: A tuple containing the initial values for the UI state.
-    """
-    key: str = list(matcher_zoo.keys())[0]  # Get the first key from matcher_zoo
-    return (
-        None,  # image0: Optional[np.ndarray]
-        None,  # image1: Optional[np.ndarray]
-        DEFAULT_MATCHING_THRESHOLD,  # matching_threshold: float
-        DEFAULT_SETTING_MAX_FEATURES,  # max_features: int
-        DEFAULT_DEFAULT_KEYPOINT_THRESHOLD,  # keypoint_threshold: float
-        key,  # matcher: str
-        ui_change_imagebox("upload"),  # input image0: Dict[str, Any]
-        ui_change_imagebox("upload"),  # input image1: Dict[str, Any]
-        "upload",  # match_image_src: str
-        None,  # keypoints: Optional[np.ndarray]
-        None,  # raw matches: Optional[np.ndarray]
-        None,  # ransac matches: Optional[np.ndarray]
-        {},  # matches result info: Dict[str, Any]
-        {},  # matcher config: Dict[str, Any]
-        None,  # warped image: Optional[np.ndarray]
-        {},  # geometry result: Dict[str, Any]
-        DEFAULT_RANSAC_METHOD,  # ransac_method: str
-        DEFAULT_RANSAC_REPROJ_THRESHOLD,  # ransac_reproj_threshold: float
-        DEFAULT_RANSAC_CONFIDENCE,  # ransac_confidence: float
-        DEFAULT_RANSAC_MAX_ITER,  # ransac_max_iter: int
-        DEFAULT_SETTING_GEOMETRY,  # geometry: str
-    )
-
-
-# "footer {visibility: hidden}"
-def run(server_name="0.0.0.0", server_port=7860):
-    """
-    Runs the application.
-
-    Args:
-        config (dict): A dictionary containing configuration parameters for the application.
-
-    Returns:
-        None
-    """
-    with gr.Blocks() as app:
-        # gr.Markdown(DESCRIPTION)
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Image(
-                    str(Path(__file__).parent / "assets/logo.webp"),
-                    elem_id="logo-img",
-                    show_label=False,
-                    show_share_button=False,
-                    show_download_button=False,
-                )
-            with gr.Column(scale=3):
-                gr.Markdown(DESCRIPTION)
-        with gr.Row(equal_height=False):
-            with gr.Column():
-                with gr.Row():
-                    matcher_list = gr.Dropdown(
-                        choices=list(matcher_zoo.keys()),
-                        value="disk+lightglue",
-                        label="Matching Model",
-                        interactive=True,
-                    )
-                    match_image_src = gr.Radio(
-                        (
-                            ["upload", "webcam", "clipboard"]
-                            if GRADIO_VERSION > "3"
-                            else ["upload", "webcam", "canvas"]
-                        ),
-                        label="Image Source",
-                        value="upload",
-                    )
-                with gr.Row():
-                    input_image0 = gr.Image(
-                        label="Image 0",
-                        type="numpy",
-                        image_mode="RGB",
-                        height=300 if GRADIO_VERSION > "3" else None,
-                        interactive=True,
-                    )
-                    input_image1 = gr.Image(
-                        label="Image 1",
-                        type="numpy",
-                        image_mode="RGB",
-                        height=300 if GRADIO_VERSION > "3" else None,
-                        interactive=True,
-                    )
-
-                with gr.Row():
-                    button_reset = gr.Button(value="Reset")
-                    button_run = gr.Button(value="Run Match", variant="primary")
-
-                with gr.Accordion("Advanced Setting", open=False):
-                    with gr.Accordion("Matching Setting", open=True):
-                        with gr.Row():
-                            match_setting_threshold = gr.Slider(
-                                minimum=0.0,
-                                maximum=1,
-                                step=0.001,
-                                label="Match thres.",
-                                value=0.1,
-                            )
-                            match_setting_max_features = gr.Slider(
-                                minimum=10,
-                                maximum=10000,
-                                step=10,
-                                label="Max features",
-                                value=1000,
-                            )
-                        # TODO: add line settings
-                        with gr.Row():
-                            detect_keypoints_threshold = gr.Slider(
-                                minimum=0,
-                                maximum=1,
-                                step=0.001,
-                                label="Keypoint thres.",
-                                value=0.015,
-                            )
-                            detect_line_threshold = gr.Slider(
-                                minimum=0.1,
-                                maximum=1,
-                                step=0.01,
-                                label="Line thres.",
-                                value=0.2,
-                            )
-                        # matcher_lists = gr.Radio(
-                        #     ["NN-mutual", "Dual-Softmax"],
-                        #     label="Matcher mode",
-                        #     value="NN-mutual",
-                        # )
-                    with gr.Accordion("RANSAC Setting", open=True):
-                        with gr.Row(equal_height=False):
-                            ransac_method = gr.Dropdown(
-                                choices=ransac_zoo.keys(),
-                                value=DEFAULT_RANSAC_METHOD,
-                                label="RANSAC Method",
-                                interactive=True,
-                            )
-                        ransac_reproj_threshold = gr.Slider(
-                            minimum=0.0,
-                            maximum=12,
-                            step=0.01,
-                            label="Ransac Reproj threshold",
-                            value=8.0,
-                        )
-                        ransac_confidence = gr.Slider(
-                            minimum=0.0,
-                            maximum=1,
-                            step=0.00001,
-                            label="Ransac Confidence",
-                            value=DEFAULT_RANSAC_CONFIDENCE,
-                        )
-                        ransac_max_iter = gr.Slider(
-                            minimum=0.0,
-                            maximum=100000,
-                            step=100,
-                            label="Ransac Iterations",
-                            value=DEFAULT_RANSAC_MAX_ITER,
-                        )
-
-                    with gr.Accordion("Geometry Setting", open=False):
-                        with gr.Row(equal_height=False):
-                            choice_estimate_geom = gr.Radio(
-                                ["Fundamental", "Homography"],
-                                label="Reconstruct Geometry",
-                                value=DEFAULT_SETTING_GEOMETRY,
-                            )
-
-                # collect inputs
-                inputs = [
-                    input_image0,
-                    input_image1,
-                    match_setting_threshold,
-                    match_setting_max_features,
-                    detect_keypoints_threshold,
-                    matcher_list,
-                    ransac_method,
-                    ransac_reproj_threshold,
-                    ransac_confidence,
-                    ransac_max_iter,
-                    choice_estimate_geom,
-                ]
-
-                # Add some examples
-                with gr.Row():
-                    # Example inputs
-                    gr.Examples(
-                        examples=gen_examples(),
-                        inputs=inputs,
-                        outputs=[],
-                        fn=run_matching,
-                        cache_examples=False,
-                        label=(
-                            "Examples (click one of the images below to Run"
-                            " Match)"
-                        ),
-                    )
-                with gr.Accordion("Open for More!", open=False):
-                    gr.Markdown(
-                        f"""
-                        <h3>Supported Algorithms</h3>
-                        {", ".join(matcher_zoo.keys())}
-                        """
-                    )
-
-            with gr.Column():
-                output_keypoints = gr.Image(label="Keypoints", type="numpy")
-                output_matches_raw = gr.Image(label="Raw Matches", type="numpy")
-                output_matches_ransac = gr.Image(
-                    label="Ransac Matches", type="numpy"
-                )
-                with gr.Accordion(
-                    "Open for More: Matches Statistics", open=False
-                ):
-                    matches_result_info = gr.JSON(label="Matches Statistics")
-                    matcher_info = gr.JSON(label="Match info")
-
-                with gr.Accordion("Open for More: Warped Image", open=False):
-                    output_wrapped = gr.Image(
-                        label="Wrapped Pair", type="numpy"
-                    )
-                    with gr.Accordion(
-                        "Open for More: Geometry info", open=False
-                    ):
-                        geometry_result = gr.JSON(
-                            label="Reconstructed Geometry"
-                        )
-
-            # callbacks
-            match_image_src.change(
-                fn=ui_change_imagebox,
-                inputs=match_image_src,
-                outputs=input_image0,
-            )
-            match_image_src.change(
-                fn=ui_change_imagebox,
-                inputs=match_image_src,
-                outputs=input_image1,
-            )
-
-            # collect outputs
-            outputs = [
-                output_keypoints,
-                output_matches_raw,
-                output_matches_ransac,
-                matches_result_info,
-                matcher_info,
-                geometry_result,
-                output_wrapped,
-            ]
-            # button callbacks
-            button_run.click(fn=run_matching, inputs=inputs, outputs=outputs)
-
-            # Reset images
-            reset_outputs = [
-                input_image0,
-                input_image1,
-                match_setting_threshold,
-                match_setting_max_features,
-                detect_keypoints_threshold,
-                matcher_list,
-                input_image0,
-                input_image1,
-                match_image_src,
-                output_keypoints,
-                output_matches_raw,
-                output_matches_ransac,
-                matches_result_info,
-                matcher_info,
-                output_wrapped,
-                geometry_result,
-                ransac_method,
-                ransac_reproj_threshold,
-                ransac_confidence,
-                ransac_max_iter,
-                choice_estimate_geom,
-            ]
-            button_reset.click(
-                fn=ui_reset_state, inputs=inputs, outputs=reset_outputs
-            )
-
-            # estimate geo
-            choice_estimate_geom.change(
-                fn=change_estimate_geom,
-                inputs=[
-                    input_image0,
-                    input_image1,
-                    geometry_result,
-                    choice_estimate_geom,
-                ],
-                outputs=[output_wrapped, geometry_result],
-            )
-    app.queue().launch(
-        server_name=server_name, server_port=server_port, share=False
-    )
-
+from common.app_class import ImageMatchingApp
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -395,6 +16,13 @@ if __name__ == "__main__":
         default=7860,
         help="server port",
     )
-
+    parser.add_argument(
+        "--config",
+        type=str,
+        default=Path(__file__).parent / "common/config.yaml",
+        help="config file",
+    )
     args = parser.parse_args()
-    run(args.server_name, args.server_port)
+    ImageMatchingApp(
+        args.server_name, args.server_port, config=args.config
+    ).run()

common/app_class.py

@@ -0,0 +1,403 @@
+import argparse
+import numpy as np
+import gradio as gr
+from pathlib import Path
+from typing import Dict, Any, Optional, Tuple, List, Union
+from common.utils import (
+    ransac_zoo,
+    change_estimate_geom,
+    load_config,
+    get_matcher_zoo,
+    run_matching,
+    gen_examples,
+    GRADIO_VERSION,
+)
+
+DESCRIPTION = """
+# Image Matching WebUI
+This Space demonstrates [Image Matching WebUI](https://github.com/Vincentqyw/image-matching-webui) by vincent qin. Feel free to play with it, or duplicate to run image matching without a queue!
+<br/>
+🔎 For more details about supported local features and matchers, please refer to https://github.com/Vincentqyw/image-matching-webui
+
+🚀 All algorithms run on CPU for inference, causing slow speeds and high latency. For faster inference, please download the [source code](https://github.com/Vincentqyw/image-matching-webui) for local deployment.
+
+🐛 Your feedback is valuable to me. Please do not hesitate to report any bugs [here](https://github.com/Vincentqyw/image-matching-webui/issues).
+"""
+
+
+class ImageMatchingApp:
+    def __init__(self, server_name="0.0.0.0", server_port=7860, **kwargs):
+        self.server_name = server_name
+        self.server_port = server_port
+        self.config_path = kwargs.get(
+            "config", Path(__file__).parent / "config.yaml"
+        )
+        self.cfg = load_config(self.config_path)
+        self.matcher_zoo = get_matcher_zoo(self.cfg["matcher_zoo"])
+        # self.ransac_zoo = get_ransac_zoo(self.cfg["ransac_zoo"])
+        self.app = None
+        self.init_interface()
+        # print all the keys
+
+    def init_interface(self):
+        with gr.Blocks() as self.app:
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Image(
+                        str(Path(__file__).parent.parent / "assets/logo.webp"),
+                        elem_id="logo-img",
+                        show_label=False,
+                        show_share_button=False,
+                        show_download_button=False,
+                    )
+                with gr.Column(scale=3):
+                    gr.Markdown(DESCRIPTION)
+            with gr.Row(equal_height=False):
+                with gr.Column():
+                    with gr.Row():
+                        matcher_list = gr.Dropdown(
+                            choices=list(self.matcher_zoo.keys()),
+                            value="disk+lightglue",
+                            label="Matching Model",
+                            interactive=True,
+                        )
+                        match_image_src = gr.Radio(
+                            (
+                                ["upload", "webcam", "clipboard"]
+                                if GRADIO_VERSION > "3"
+                                else ["upload", "webcam", "canvas"]
+                            ),
+                            label="Image Source",
+                            value="upload",
+                        )
+                    with gr.Row():
+                        input_image0 = gr.Image(
+                            label="Image 0",
+                            type="numpy",
+                            image_mode="RGB",
+                            height=300 if GRADIO_VERSION > "3" else None,
+                            interactive=True,
+                        )
+                        input_image1 = gr.Image(
+                            label="Image 1",
+                            type="numpy",
+                            image_mode="RGB",
+                            height=300 if GRADIO_VERSION > "3" else None,
+                            interactive=True,
+                        )
+
+                    with gr.Row():
+                        button_reset = gr.Button(value="Reset")
+                        button_run = gr.Button(
+                            value="Run Match", variant="primary"
+                        )
+
+                    with gr.Accordion("Advanced Setting", open=False):
+                        with gr.Accordion("Matching Setting", open=True):
+                            with gr.Row():
+                                match_setting_threshold = gr.Slider(
+                                    minimum=0.0,
+                                    maximum=1,
+                                    step=0.001,
+                                    label="Match thres.",
+                                    value=0.1,
+                                )
+                                match_setting_max_features = gr.Slider(
+                                    minimum=10,
+                                    maximum=10000,
+                                    step=10,
+                                    label="Max features",
+                                    value=1000,
+                                )
+                            # TODO: add line settings
+                            with gr.Row():
+                                detect_keypoints_threshold = gr.Slider(
+                                    minimum=0,
+                                    maximum=1,
+                                    step=0.001,
+                                    label="Keypoint thres.",
+                                    value=0.015,
+                                )
+                                detect_line_threshold = gr.Slider(
+                                    minimum=0.1,
+                                    maximum=1,
+                                    step=0.01,
+                                    label="Line thres.",
+                                    value=0.2,
+                                )
+                            # matcher_lists = gr.Radio(
+                            #     ["NN-mutual", "Dual-Softmax"],
+                            #     label="Matcher mode",
+                            #     value="NN-mutual",
+                            # )
+                        with gr.Accordion("RANSAC Setting", open=True):
+                            with gr.Row(equal_height=False):
+                                ransac_method = gr.Dropdown(
+                                    choices=ransac_zoo.keys(),
+                                    value=self.cfg["defaults"]["ransac_method"],
+                                    label="RANSAC Method",
+                                    interactive=True,
+                                )
+                            ransac_reproj_threshold = gr.Slider(
+                                minimum=0.0,
+                                maximum=12,
+                                step=0.01,
+                                label="Ransac Reproj threshold",
+                                value=8.0,
+                            )
+                            ransac_confidence = gr.Slider(
+                                minimum=0.0,
+                                maximum=1,
+                                step=0.00001,
+                                label="Ransac Confidence",
+                                value=self.cfg["defaults"]["ransac_confidence"],
+                            )
+                            ransac_max_iter = gr.Slider(
+                                minimum=0.0,
+                                maximum=100000,
+                                step=100,
+                                label="Ransac Iterations",
+                                value=self.cfg["defaults"]["ransac_max_iter"],
+                            )
+
+                        with gr.Accordion("Geometry Setting", open=False):
+                            with gr.Row(equal_height=False):
+                                choice_estimate_geom = gr.Radio(
+                                    ["Fundamental", "Homography"],
+                                    label="Reconstruct Geometry",
+                                    value=self.cfg["defaults"][
+                                        "setting_geometry"
+                                    ],
+                                )
+
+                    # collect inputs
+                    inputs = [
+                        input_image0,
+                        input_image1,
+                        match_setting_threshold,
+                        match_setting_max_features,
+                        detect_keypoints_threshold,
+                        matcher_list,
+                        ransac_method,
+                        ransac_reproj_threshold,
+                        ransac_confidence,
+                        ransac_max_iter,
+                        choice_estimate_geom,
+                        gr.State(self.matcher_zoo),
+                    ]
+
+                    # Add some examples
+                    with gr.Row():
+                        # Example inputs
+                        gr.Examples(
+                            examples=gen_examples(),
+                            inputs=inputs,
+                            outputs=[],
+                            fn=run_matching,
+                            cache_examples=False,
+                            label=(
+                                "Examples (click one of the images below to Run"
+                                " Match)"
+                            ),
+                        )
+                    with gr.Accordion("Open for More!", open=False):
+                        gr.Markdown(
+                            f"""
+                            <h3>Supported Algorithms</h3>
+                            {", ".join(self.matcher_zoo.keys())}
+                            """
+                        )
+
+                with gr.Column():
+                    output_keypoints = gr.Image(label="Keypoints", type="numpy")
+                    output_matches_raw = gr.Image(
+                        label="Raw Matches", type="numpy"
+                    )
+                    output_matches_ransac = gr.Image(
+                        label="Ransac Matches", type="numpy"
+                    )
+                    with gr.Accordion(
+                        "Open for More: Matches Statistics", open=False
+                    ):
+                        matches_result_info = gr.JSON(
+                            label="Matches Statistics"
+                        )
+                        matcher_info = gr.JSON(label="Match info")
+
+                    with gr.Accordion(
+                        "Open for More: Warped Image", open=False
+                    ):
+                        output_wrapped = gr.Image(
+                            label="Wrapped Pair", type="numpy"
+                        )
+                        with gr.Accordion(
+                            "Open for More: Geometry info", open=False
+                        ):
+                            geometry_result = gr.JSON(
+                                label="Reconstructed Geometry"
+                            )
+
+                # callbacks
+                match_image_src.change(
+                    fn=self.ui_change_imagebox,
+                    inputs=match_image_src,
+                    outputs=input_image0,
+                )
+                match_image_src.change(
+                    fn=self.ui_change_imagebox,
+                    inputs=match_image_src,
+                    outputs=input_image1,
+                )
+
+                # collect outputs
+                outputs = [
+                    output_keypoints,
+                    output_matches_raw,
+                    output_matches_ransac,
+                    matches_result_info,
+                    matcher_info,
+                    geometry_result,
+                    output_wrapped,
+                ]
+                # button callbacks
+                button_run.click(
+                    fn=run_matching, inputs=inputs, outputs=outputs
+                )
+
+                # Reset images
+                reset_outputs = [
+                    input_image0,
+                    input_image1,
+                    match_setting_threshold,
+                    match_setting_max_features,
+                    detect_keypoints_threshold,
+                    matcher_list,
+                    input_image0,
+                    input_image1,
+                    match_image_src,
+                    output_keypoints,
+                    output_matches_raw,
+                    output_matches_ransac,
+                    matches_result_info,
+                    matcher_info,
+                    output_wrapped,
+                    geometry_result,
+                    ransac_method,
+                    ransac_reproj_threshold,
+                    ransac_confidence,
+                    ransac_max_iter,
+                    choice_estimate_geom,
+                ]
+                button_reset.click(
+                    fn=self.ui_reset_state, inputs=inputs, outputs=reset_outputs
+                )
+
+                # estimate geo
+                choice_estimate_geom.change(
+                    fn=change_estimate_geom,
+                    inputs=[
+                        input_image0,
+                        input_image1,
+                        geometry_result,
+                        choice_estimate_geom,
+                    ],
+                    outputs=[output_wrapped, geometry_result],
+                )
+
+    def run(self):
+        self.app.queue().launch(
+            server_name=self.server_name,
+            server_port=self.server_port,
+            share=False,
+        )
+
+    def ui_change_imagebox(self, choice):
+        """
+        Updates the image box with the given choice.
+
+        Args:
+            choice (list): The list of image sources to be displayed in the image box.
+
+        Returns:
+            dict: A dictionary containing the updated value, sources, and type for the image box.
+        """
+        ret_dict = {
+            "value": None,  # The updated value of the image box
+            "__type__": "update",  # The type of update for the image box
+        }
+        if GRADIO_VERSION > "3":
+            return {
+                **ret_dict,
+                "sources": choice,  # The list of image sources to be displayed
+            }
+        else:
+            return {
+                **ret_dict,
+                "source": choice,  # The list of image sources to be displayed
+            }
+
+    def ui_reset_state(
+        self,
+        *args: Any,
+    ) -> Tuple[
+        Optional[np.ndarray],
+        Optional[np.ndarray],
+        float,
+        int,
+        float,
+        str,
+        Dict[str, Any],
+        Dict[str, Any],
+        str,
+        Optional[np.ndarray],
+        Optional[np.ndarray],
+        Optional[np.ndarray],
+        Dict[str, Any],
+        Dict[str, Any],
+        Optional[np.ndarray],
+        Dict[str, Any],
+        str,
+        int,
+        float,
+        int,
+    ]:
+        """
+        Reset the state of the UI.
+
+        Returns:
+            tuple: A tuple containing the initial values for the UI state.
+        """
+        key: str = list(self.matcher_zoo.keys())[
+            0
+        ]  # Get the first key from matcher_zoo
+        return (
+            None,  # image0: Optional[np.ndarray]
+            None,  # image1: Optional[np.ndarray]
+            self.cfg["defaults"][
+                "match_threshold"
+            ],  # matching_threshold: float
+            self.cfg["defaults"]["max_keypoints"],  # max_features: int
+            self.cfg["defaults"][
+                "keypoint_threshold"
+            ],  # keypoint_threshold: float
+            key,  # matcher: str
+            self.ui_change_imagebox("upload"),  # input image0: Dict[str, Any]
+            self.ui_change_imagebox("upload"),  # input image1: Dict[str, Any]
+            "upload",  # match_image_src: str
+            None,  # keypoints: Optional[np.ndarray]
+            None,  # raw matches: Optional[np.ndarray]
+            None,  # ransac matches: Optional[np.ndarray]
+            {},  # matches result info: Dict[str, Any]
+            {},  # matcher config: Dict[str, Any]
+            None,  # warped image: Optional[np.ndarray]
+            {},  # geometry result: Dict[str, Any]
+            self.cfg["defaults"]["ransac_method"],  # ransac_method: str
+            self.cfg["defaults"][
+                "ransac_reproj_threshold"
+            ],  # ransac_reproj_threshold: float
+            self.cfg["defaults"][
+                "ransac_confidence"
+            ],  # ransac_confidence: float
+            self.cfg["defaults"]["ransac_max_iter"],  # ransac_max_iter: int
+            self.cfg["defaults"]["setting_geometry"],  # geometry: str
+        )

common/config.yaml

@@ -0,0 +1,108 @@
+server:
+  name: "0.0.0.0"
+  port: 7860
+
+defaults:
+  setting_threshold: 0.1
+  max_keypoints: 2000
+  keypoint_threshold: 0.05
+  enable_ransac: true
+  ransac_method: USAC_MAGSAC
+  ransac_reproj_threshold: 8
+  ransac_confidence: 0.999
+  ransac_max_iter: 10000
+  ransac_num_samples: 4
+  match_threshold: 0.2
+  setting_geometry: Homography
+
+matcher_zoo:
+  roma:
+    matcher: roma
+    dense: true
+  loftr:
+    matcher: loftr
+    dense: true
+  topicfm:
+    matcher: topicfm
+    dense: true
+  aspanformer:
+    matcher: aspanformer
+    dense: true
+  dedode:
+    matcher: Dual-Softmax
+    feature: dedode
+    dense: false
+  superpoint+superglue:
+    matcher: superglue
+    feature: superpoint_max
+    dense: false
+  superpoint+lightglue:
+    matcher: superpoint-lightglue
+    feature: superpoint_max
+    dense: false
+  disk:
+    matcher: NN-mutual
+    feature: disk
+    dense: false
+  disk+dualsoftmax:
+    matcher: Dual-Softmax
+    feature: disk
+    dense: false
+  superpoint+dualsoftmax:
+    matcher: Dual-Softmax
+    feature: superpoint_max
+    dense: false
+  disk+lightglue:
+    matcher: disk-lightglue
+    feature: disk
+    dense: false
+  superpoint+mnn:
+    matcher: NN-mutual
+    feature: superpoint_max
+    dense: false
+  sift+sgmnet:
+    matcher: sgmnet
+    feature: sift
+    dense: false
+  sosnet:
+    matcher: NN-mutual
+    feature: sosnet
+    dense: false
+  hardnet:
+    matcher: NN-mutual
+    feature: hardnet
+    dense: false
+  d2net:
+    matcher: NN-mutual
+    feature: d2net-ss
+    dense: false
+  rord:
+    matcher: NN-mutual
+    feature: rord
+    dense: false
+  alike:
+    matcher: NN-mutual
+    feature: alike
+    dense: false
+  lanet:
+    matcher: NN-mutual
+    feature: lanet
+    dense: false
+  r2d2:
+    matcher: NN-mutual
+    feature: r2d2
+    dense: false
+  darkfeat:
+    matcher: NN-mutual
+    feature: darkfeat
+    dense: false
+  sift:
+    matcher: NN-mutual
+    feature: sift
+    dense: false
+  gluestick:
+    matcher: gluestick
+    dense: true
+  sold2:
+    matcher: sold2
+    dense: true

common/utils.py

@@ -1,20 +1,27 @@
 import os
+import cv2
+import torch
 import random
 import numpy as np
-import torch
-import cv2
 import gradio as gr
 from pathlib import Path
-from typing import Dict, Any, Optional, Tuple, List, Union
 from itertools import combinations
+from typing import Callable, Dict, Any, Optional, Tuple, List, Union
 from hloc import matchers, extractors, logger
 from hloc.utils.base_model import dynamic_load
 from hloc import match_dense, match_features, extract_features
 from hloc.utils.viz import add_text, plot_keypoints
-from .viz import draw_matches, fig2im, plot_images, plot_color_line_matches
+from .viz import (
+    draw_matches,
+    fig2im,
+    plot_images,
+    display_matches,
+    plot_color_line_matches,
+)
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
+ROOT = Path(__file__).parent.parent
 DEFAULT_SETTING_THRESHOLD = 0.1
 DEFAULT_SETTING_MAX_FEATURES = 2000
 DEFAULT_DEFAULT_KEYPOINT_THRESHOLD = 0.01
@@ -27,6 +34,58 @@ DEFAULT_MIN_NUM_MATCHES = 4
 DEFAULT_MATCHING_THRESHOLD = 0.2
 DEFAULT_SETTING_GEOMETRY = "Homography"
 GRADIO_VERSION = gr.__version__.split(".")[0]
+MATCHER_ZOO = None
+
+
+def load_config(config_name: str) -> Dict[str, Any]:
+    """
+    Load a YAML configuration file.
+
+    Args:
+        config_name: The path to the YAML configuration file.
+
+    Returns:
+        The configuration dictionary, with string keys and arbitrary values.
+    """
+    import yaml
+
+    with open(config_name, "r") as stream:
+        try:
+            config: Dict[str, Any] = yaml.safe_load(stream)
+        except yaml.YAMLError as exc:
+            logger.error(exc)
+    return config
+
+
+def get_matcher_zoo(
+    matcher_zoo: Dict[str, Dict[str, Union[str, bool]]]
+) -> Dict[str, Dict[str, Union[Callable, bool]]]:
+    """
+    Restore matcher configurations from a dictionary.
+
+    Args:
+        matcher_zoo: A dictionary with the matcher configurations,
+            where the configuration is a dictionary as loaded from a YAML file.
+
+    Returns:
+        A dictionary with the matcher configurations, where the configuration is
+            a function or a function instead of a string.
+    """
+    matcher_zoo_restored = {}
+    for k, v in matcher_zoo.items():
+        dense = v["dense"]
+        if dense:
+            matcher_zoo_restored[k] = {
+                "matcher": match_dense.confs.get(v["matcher"]),
+                "dense": dense,
+            }
+        else:
+            matcher_zoo_restored[k] = {
+                "feature": extract_features.confs.get(v["feature"]),
+                "matcher": match_features.confs.get(v["matcher"]),
+                "dense": dense,
+            }
+    return matcher_zoo_restored
 
 
 def get_model(match_conf: Dict[str, Any]):
@@ -83,7 +142,7 @@ def gen_examples():
         return [pairs[i] for i in selected]
 
     # image pair path
-    path = Path(__file__).parent.parent / "datasets/sacre_coeur/mapping"
+    path = ROOT / "datasets/sacre_coeur/mapping"
     pairs = gen_images_pairs(str(path), len(example_matchers))
     match_setting_threshold = DEFAULT_SETTING_THRESHOLD
     match_setting_max_features = DEFAULT_SETTING_MAX_FEATURES
@@ -343,85 +402,6 @@ def change_estimate_geom(
         return None, None
 
 
-def display_matches(
-    pred: Dict[str, np.ndarray], titles: List[str] = [], dpi: int = 300
-) -> Tuple[np.ndarray, int]:
-    """
-    Displays the matches between two images.
-
-    Args:
-        pred: Dictionary containing the original images and the matches.
-        titles: Optional titles for the plot.
-        dpi: Resolution of the plot.
-
-    Returns:
-        The resulting concatenated plot and the number of inliers.
-    """
-    img0 = pred["image0_orig"]
-    img1 = pred["image1_orig"]
-
-    num_inliers = 0
-    if (
-        "keypoints0_orig" in pred
-        and "keypoints1_orig" in pred
-        and pred["keypoints0_orig"] is not None
-        and pred["keypoints1_orig"] is not None
-    ):
-        mkpts0 = pred["keypoints0_orig"]
-        mkpts1 = pred["keypoints1_orig"]
-        num_inliers = len(mkpts0)
-        if "mconf" in pred:
-            mconf = pred["mconf"]
-        else:
-            mconf = np.ones(len(mkpts0))
-        fig_mkpts = draw_matches(
-            mkpts0,
-            mkpts1,
-            img0,
-            img1,
-            mconf,
-            dpi=dpi,
-            titles=titles,
-        )
-        fig = fig_mkpts
-    if (
-        "line0_orig" in pred
-        and "line1_orig" in pred
-        and pred["line0_orig"] is not None
-        and pred["line1_orig"] is not None
-    ):
-        # lines
-        mtlines0 = pred["line0_orig"]
-        mtlines1 = pred["line1_orig"]
-        num_inliers = len(mtlines0)
-        fig_lines = plot_images(
-            [img0.squeeze(), img1.squeeze()],
-            ["Image 0 - matched lines", "Image 1 - matched lines"],
-            dpi=300,
-        )
-        fig_lines = plot_color_line_matches([mtlines0, mtlines1], lw=2)
-        fig_lines = fig2im(fig_lines)
-
-        # keypoints
-        mkpts0 = pred.get("line_keypoints0_orig")
-        mkpts1 = pred.get("line_keypoints1_orig")
-
-        if mkpts0 is not None and mkpts1 is not None:
-            num_inliers = len(mkpts0)
-            if "mconf" in pred:
-                mconf = pred["mconf"]
-            else:
-                mconf = np.ones(len(mkpts0))
-            fig_mkpts = draw_matches(mkpts0, mkpts1, img0, img1, mconf, dpi=300)
-            fig_lines = cv2.resize(
-                fig_lines, (fig_mkpts.shape[1], fig_mkpts.shape[0])
-            )
-            fig = np.concatenate([fig_mkpts, fig_lines], axis=0)
-        else:
-            fig = fig_lines
-    return fig, num_inliers
-
-
 def run_matching(
     image0: np.ndarray,
     image1: np.ndarray,
@@ -434,6 +414,7 @@ def run_matching(
     ransac_confidence: float = DEFAULT_RANSAC_CONFIDENCE,
     ransac_max_iter: int = DEFAULT_RANSAC_MAX_ITER,
     choice_estimate_geom: str = DEFAULT_SETTING_GEOMETRY,
+    matcher_zoo: Dict[str, Any] = None,
 ) -> Tuple[
     np.ndarray,
     np.ndarray,
@@ -477,7 +458,7 @@ def run_matching(
     output_matches_ransac = None
 
     model = matcher_zoo[key]
-    match_conf = model["config"]
+    match_conf = model["matcher"]
     # update match config
     match_conf["model"]["match_threshold"] = match_threshold
     match_conf["model"]["max_keypoints"] = extract_max_keypoints
@@ -490,7 +471,7 @@ def run_matching(
         del matcher
         extract_conf = None
     else:
-        extract_conf = model["config_feature"]
+        extract_conf = model["feature"]
         # update extract config
         extract_conf["model"]["max_keypoints"] = extract_max_keypoints
         extract_conf["model"]["keypoint_threshold"] = keypoint_threshold
@@ -587,113 +568,3 @@ ransac_zoo = {
     "USAC_ACCURATE": cv2.USAC_ACCURATE,
     "USAC_PARALLEL": cv2.USAC_PARALLEL,
 }
-
-# Matchers collections
-matcher_zoo = {
-    # 'dedode-sparse': {
-    #     'config': match_dense.confs['dedode_sparse'],
-    #     'dense': True  # dense mode, we need 2 images
-    # },
-    "roma": {"config": match_dense.confs["roma"], "dense": True},
-    "loftr": {"config": match_dense.confs["loftr"], "dense": True},
-    "topicfm": {"config": match_dense.confs["topicfm"], "dense": True},
-    "aspanformer": {"config": match_dense.confs["aspanformer"], "dense": True},
-    "dedode": {
-        "config": match_features.confs["Dual-Softmax"],
-        "config_feature": extract_features.confs["dedode"],
-        "dense": False,
-    },
-    "superpoint+superglue": {
-        "config": match_features.confs["superglue"],
-        "config_feature": extract_features.confs["superpoint_max"],
-        "dense": False,
-    },
-    "superpoint+lightglue": {
-        "config": match_features.confs["superpoint-lightglue"],
-        "config_feature": extract_features.confs["superpoint_max"],
-        "dense": False,
-    },
-    "disk": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["disk"],
-        "dense": False,
-    },
-    "disk+dualsoftmax": {
-        "config": match_features.confs["Dual-Softmax"],
-        "config_feature": extract_features.confs["disk"],
-        "dense": False,
-    },
-    "superpoint+dualsoftmax": {
-        "config": match_features.confs["Dual-Softmax"],
-        "config_feature": extract_features.confs["superpoint_max"],
-        "dense": False,
-    },
-    "disk+lightglue": {
-        "config": match_features.confs["disk-lightglue"],
-        "config_feature": extract_features.confs["disk"],
-        "dense": False,
-    },
-    "superpoint+mnn": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["superpoint_max"],
-        "dense": False,
-    },
-    "sift+sgmnet": {
-        "config": match_features.confs["sgmnet"],
-        "config_feature": extract_features.confs["sift"],
-        "dense": False,
-    },
-    "sosnet": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["sosnet"],
-        "dense": False,
-    },
-    "hardnet": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["hardnet"],
-        "dense": False,
-    },
-    "d2net": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["d2net-ss"],
-        "dense": False,
-    },
-    "rord": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["rord"],
-        "dense": False,
-    },
-    # "d2net-ms": {
-    #     "config": match_features.confs["NN-mutual"],
-    #     "config_feature": extract_features.confs["d2net-ms"],
-    #     "dense": False,
-    # },
-    "alike": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["alike"],
-        "dense": False,
-    },
-    "lanet": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["lanet"],
-        "dense": False,
-    },
-    "r2d2": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["r2d2"],
-        "dense": False,
-    },
-    "darkfeat": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["darkfeat"],
-        "dense": False,
-    },
-    "sift": {
-        "config": match_features.confs["NN-mutual"],
-        "config_feature": extract_features.confs["sift"],
-        "dense": False,
-    },
-    "gluestick": {"config": match_dense.confs["gluestick"], "dense": True},
-    "sold2": {"config": match_dense.confs["sold2"], "dense": True},
-    # "DKMv3": {"config": match_dense.confs["dkm"], "dense": True},
-}

common/viz.py

@@ -367,3 +367,82 @@ def draw_image_pairs(
         plt.close()
     else:
         return fig2im(fig)
+
+
+def display_matches(
+    pred: Dict[str, np.ndarray], titles: List[str] = [], dpi: int = 300
+) -> Tuple[np.ndarray, int]:
+    """
+    Displays the matches between two images.
+
+    Args:
+        pred: Dictionary containing the original images and the matches.
+        titles: Optional titles for the plot.
+        dpi: Resolution of the plot.
+
+    Returns:
+        The resulting concatenated plot and the number of inliers.
+    """
+    img0 = pred["image0_orig"]
+    img1 = pred["image1_orig"]
+
+    num_inliers = 0
+    if (
+        "keypoints0_orig" in pred
+        and "keypoints1_orig" in pred
+        and pred["keypoints0_orig"] is not None
+        and pred["keypoints1_orig"] is not None
+    ):
+        mkpts0 = pred["keypoints0_orig"]
+        mkpts1 = pred["keypoints1_orig"]
+        num_inliers = len(mkpts0)
+        if "mconf" in pred:
+            mconf = pred["mconf"]
+        else:
+            mconf = np.ones(len(mkpts0))
+        fig_mkpts = draw_matches(
+            mkpts0,
+            mkpts1,
+            img0,
+            img1,
+            mconf,
+            dpi=dpi,
+            titles=titles,
+        )
+        fig = fig_mkpts
+    if (
+        "line0_orig" in pred
+        and "line1_orig" in pred
+        and pred["line0_orig"] is not None
+        and pred["line1_orig"] is not None
+    ):
+        # lines
+        mtlines0 = pred["line0_orig"]
+        mtlines1 = pred["line1_orig"]
+        num_inliers = len(mtlines0)
+        fig_lines = plot_images(
+            [img0.squeeze(), img1.squeeze()],
+            ["Image 0 - matched lines", "Image 1 - matched lines"],
+            dpi=300,
+        )
+        fig_lines = plot_color_line_matches([mtlines0, mtlines1], lw=2)
+        fig_lines = fig2im(fig_lines)
+
+        # keypoints
+        mkpts0 = pred.get("line_keypoints0_orig")
+        mkpts1 = pred.get("line_keypoints1_orig")
+
+        if mkpts0 is not None and mkpts1 is not None:
+            num_inliers = len(mkpts0)
+            if "mconf" in pred:
+                mconf = pred["mconf"]
+            else:
+                mconf = np.ones(len(mkpts0))
+            fig_mkpts = draw_matches(mkpts0, mkpts1, img0, img1, mconf, dpi=300)
+            fig_lines = cv2.resize(
+                fig_lines, (fig_mkpts.shape[1], fig_mkpts.shape[0])
+            )
+            fig = np.concatenate([fig_mkpts, fig_lines], axis=0)
+        else:
+            fig = fig_lines
+    return fig, num_inliers