ruff formatted

src/ouroboros-keypoint-match/common/keypoint_matcher.py

@@ -1,5 +1,6 @@
 from .matcher_base import MatcherBase
 
+
 class KeypointMatcher:
     def set_matcher(self, matcher: MatcherBase):
         self.matcher = matcher
@@ -12,7 +13,7 @@ def load_image(self, img_path, resize=None):
                 resize (tuple of int, optional): Desired size to resize the images to, specified as (height, width).
         """
         return self.matcher.load_image(img_path, resize)
-    
+
     def execute(self, img0, img1):
         """
         Performs image matching using the selected strategy.
@@ -21,7 +22,7 @@ def execute(self, img0, img1):
                 img1 (Tensor): Second image to be matched.
                 max_num_keypoints (int): Maximum number of keypoints to be found.
                 device (str, optional): The device to run the matching on, either "cuda" or "cpu".
-                
+
             Returns:
                 kpts0 (Tensor): Keypoints detected in the first image after feature extraction.
                 kpts1 (Tensor): Keypoints detected in the second image after feature extraction.

src/ouroboros-keypoint-match/common/matcher_base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+
 class MatcherBase(ABC):
     @abstractmethod
     def __init__(self, max_num_keypoints=2048, device=None):

src/ouroboros-keypoint-match/lightglue/lightglue_matcher.py

@@ -8,14 +8,17 @@
 import matplotlib.pyplot as plt
 import torch
 
+
 class LightGlueMatcher(MatcherBase):
     def __init__(self, max_num_keypoints=2048, device=None):
         if device is None:
             self.device = "cuda" if torch.cuda.is_available() else "cpu"
         else:
             self.device = device
 
-        self.extractor = SuperPoint(max_num_keypoints=max_num_keypoints).eval().to(self.device)
+        self.extractor = (
+            SuperPoint(max_num_keypoints=max_num_keypoints).eval().to(self.device)
+        )
         self.matcher = LightGlue(features="superpoint").eval().to(self.device)
 
     def load_image(self, img_path, resize):
@@ -30,10 +33,16 @@ def execute(self, img0, img1):
 
         # Match the features
         matches01 = self.matcher({"image0": feats0, "image1": feats1})
-        feats0, feats1, matches01 = [rbd(x) for x in [feats0, feats1, matches01]]  # remove batch dimension
+        feats0, feats1, matches01 = [
+            rbd(x) for x in [feats0, feats1, matches01]
+        ]  # remove batch dimension
 
         # Keep the matching keypoints
-        kpts0, kpts1, matches = feats0["keypoints"], feats1["keypoints"], matches01["matches"]
+        kpts0, kpts1, matches = (
+            feats0["keypoints"],
+            feats1["keypoints"],
+            matches01["matches"],
+        )
         m_kpts0, m_kpts1 = kpts0[matches[..., 0]], kpts1[matches[..., 1]]
 
         return kpts0, kpts1, m_kpts0, m_kpts1
@@ -49,4 +58,3 @@ def get_matcher_model(self):
 
     def get_descriptor_model(self):
         return self.extractor
-

src/ouroboros-keypoint-match/lightglue/superpoint.py

@@ -81,9 +81,7 @@ def sample_descriptors(keypoints, descriptors, s: int = 8):
     keypoints = keypoints - s / 2 + 0.5
     keypoints /= torch.tensor(
         [(w * s - s / 2 - 0.5), (h * s - s / 2 - 0.5)],
-    ).to(
-        keypoints
-    )[None]
+    ).to(keypoints)[None]
     keypoints = keypoints * 2 - 1  # normalize to (-1, 1)
     args = {"align_corners": True} if torch.__version__ >= "1.3" else {}
     descriptors = torch.nn.functional.grid_sample(

src/ouroboros-keypoint-match/superglue/matching.py

@@ -47,28 +47,29 @@
 
 
 class Matching(torch.nn.Module):
-    """ Image Matching Frontend (SuperPoint + SuperGlue) """
+    """Image Matching Frontend (SuperPoint + SuperGlue)"""
+
     def __init__(self, config={}):
         super().__init__()
-        self.superpoint = SuperPoint(config.get('superpoint', {}))
-        self.superglue = SuperGlue(config.get('superglue', {}))
+        self.superpoint = SuperPoint(config.get("superpoint", {}))
+        self.superglue = SuperGlue(config.get("superglue", {}))
 
     @torch.no_grad()
     def forward(self, data):
-        """ Run SuperPoint (optionally) and SuperGlue
+        """Run SuperPoint (optionally) and SuperGlue
         SuperPoint is skipped if ['keypoints0', 'keypoints1'] exist in input
         Args:
           data: dictionary with minimal keys: ['image0', 'image1']
         """
         pred = {}
 
         # Extract SuperPoint (keypoints, scores, descriptors) if not provided
-        if 'keypoints0' not in data:
-            pred0 = self.superpoint({'image': data['image0']})
-            pred = {**pred, **{k+'0': v for k, v in pred0.items()}}
-        if 'keypoints1' not in data:
-            pred1 = self.superpoint({'image': data['image1']})
-            pred = {**pred, **{k+'1': v for k, v in pred1.items()}}
+        if "keypoints0" not in data:
+            pred0 = self.superpoint({"image": data["image0"]})
+            pred = {**pred, **{k + "0": v for k, v in pred0.items()}}
+        if "keypoints1" not in data:
+            pred1 = self.superpoint({"image": data["image1"]})
+            pred = {**pred, **{k + "1": v for k, v in pred1.items()}}
 
         # Batch all features
         # We should either have i) one image per batch, or