missing files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,17 +1,17 @@
 import gradio as gr
-from style_transfer import StyleTransfer
+from delf import DeepLocalFeatures
 
-style = StyleTransfer()
+delf = DeepLocalFeatures()
 
 
-def predict(content_image, style_image):
-    return style.transfer(content_image, style_image)
+def predict(image_a, image_b):
+    return delf.match(image_a, image_b)
 
 
 footer = r"""
 <center>
 <b>
-Demo for <a href='https://www.tensorflow.org/hub/tutorials/tf2_arbitrary_image_stylization'>Style Transfer</a>
+Demo for <a href='https://www.tensorflow.org/hub/tutorials/tf_hub_delf_module'>DELF</a>
 </b>
 </center>
 """
@@ -25,28 +25,29 @@ coffee&emoji=&slug=leonelhs&button_colour=FFDD00&font_colour=000000&font_family=
 </center>
 """
 
-with gr.Blocks(title="Style Transfer") as app:
-    gr.HTML("<center><h1>Style Transfer</h1></center>")
-    gr.HTML("<center><h3>Fast Style Transfer for Arbitrary Styles</h3></center>")
+with gr.Blocks(title="DELF") as app:
+    gr.HTML("<center><h1>Match images using DELF</h1></center>")
+    gr.HTML("<center><h3>Neural network and logic for processing images to identify keypoints and their "
+            "descriptors.</h3></center>")
     with gr.Row(equal_height=False):
         with gr.Column():
-            content_img = gr.Image(type="filepath", label="Content image")
-            style_img = gr.Image(type="filepath", label="Style image")
+            input_img_a = gr.Image(type="pil", label="Input image A")
+            input_img_b = gr.Image(type="pil", label="Input image B")
             run_btn = gr.Button(variant="primary")
         with gr.Column():
             output_img = gr.Image(type="pil", label="Output image")
-            gr.ClearButton(components=[content_img, style_img, output_img], variant="stop")
+            gr.ClearButton(components=[input_img_a, input_img_b, output_img], variant="stop")
 
-    run_btn.click(predict, [content_img, style_img], [output_img])
+    run_btn.click(predict, [input_img_a, input_img_b], [output_img])
 
     with gr.Row():
-        blobs_c = [[f"examples/contents/{x:02d}.jpg"] for x in range(1, 4)]
-        examples_c = gr.Dataset(components=[content_img], samples=blobs_c)
-        examples_c.click(lambda x: x[0], [examples_c], [content_img])
+        blobs_a = [[f"examples/image_a/{x:02d}.jpg"] for x in range(1, 5)]
+        examples_a = gr.Dataset(components=[input_img_a], samples=blobs_a)
+        examples_a.click(lambda x: x[0], [examples_a], [input_img_a])
     with gr.Row():
-        blobs_s = [[f"examples/styles/{x:02d}.jpg"] for x in range(1, 12)]
-        examples_s = gr.Dataset(components=[style_img], samples=blobs_s)
-        examples_s.click(lambda x: x[0], [examples_s], [style_img])
+        blobs_b = [[f"examples/image_b/{x:02d}.jpg"] for x in range(1, 5)]
+        examples_b = gr.Dataset(components=[input_img_b], samples=blobs_b)
+        examples_b.click(lambda x: x[0], [examples_b], [input_img_b])
 
     with gr.Row():
         gr.HTML(footer)

delf.py

@@ -0,0 +1,108 @@
+#############################################################################
+#
+#   Source from:
+#   https://www.tensorflow.org/hub/tutorials/tf_hub_delf_module
+#   Forked from:
+#   https://www.tensorflow.org/hub/tutorials/tf_hub_delf_module
+#   Reimplemented by: Leonel Hernández
+#
+##############################################################################
+import matplotlib.pyplot as plt
+import numpy as np
+import tensorflow as tf
+from PIL import Image, ImageOps
+from huggingface_hub import snapshot_download
+from scipy.spatial import cKDTree
+from skimage.feature import plot_matches
+from skimage.measure import ransac
+from skimage.transform import AffineTransform
+
+DELF_REPO_ID = "leonelhs/delf"
+
+
+def match_images(image1, image2, result1, result2):
+    distance_threshold = 0.8
+
+    # Read features.
+    num_features_1 = result1['locations'].shape[0]
+    print("Loaded image 1's %d features" % num_features_1)
+
+    num_features_2 = result2['locations'].shape[0]
+    print("Loaded image 2's %d features" % num_features_2)
+
+    # Find nearest-neighbor matches using a KD tree.
+    d1_tree = cKDTree(result1['descriptors'])
+    _, indices = d1_tree.query(
+        result2['descriptors'],
+        distance_upper_bound=distance_threshold)
+
+    # Select feature locations for putative matches.
+    locations_2_to_use = np.array([
+        result2['locations'][i,]
+        for i in range(num_features_2)
+        if indices[i] != num_features_1
+    ])
+    locations_1_to_use = np.array([
+        result1['locations'][indices[i],]
+        for i in range(num_features_2)
+        if indices[i] != num_features_1
+    ])
+
+    # Perform geometric verification using RANSAC.
+    _, inliers = ransac(
+        (locations_1_to_use, locations_2_to_use),
+        AffineTransform,
+        min_samples=3,
+        residual_threshold=20,
+        max_trials=1000)
+
+    print('Found %d inliers' % sum(inliers))
+
+    # Visualize correspondences.
+    fig, ax = plt.subplots()
+    inlier_idxs = np.nonzero(inliers)[0]
+    stack = np.column_stack((inlier_idxs, inlier_idxs))
+    plot_matches(
+        ax,
+        image1,
+        image2,
+        locations_1_to_use,
+        locations_2_to_use,
+        stack,
+        matches_color='b')
+    ax.axis('off')
+    ax.set_title('DELF correspondences')
+
+    fig.canvas.draw()
+    image_array = np.array(fig.canvas.renderer.buffer_rgba())
+    image = Image.fromarray(image_array)
+    return image.convert("RGB")
+
+
+def crop_image(image, width=256, height=256):
+    return ImageOps.fit(image, (width, height), Image.LANCZOS)
+
+
+class DeepLocalFeatures:
+
+    def __init__(self):
+        model_path = snapshot_download(DELF_REPO_ID)
+        self.model = tf.saved_model.load(model_path).signatures['default']
+
+    def run_delf(self, image):
+        np_image = np.array(image)
+        float_image = tf.image.convert_image_dtype(np_image, tf.float32)
+
+        return self.model(
+            image=float_image,
+            score_threshold=tf.constant(100.0),
+            image_scales=tf.constant([0.25, 0.3536, 0.5, 0.7071, 1.0, 1.4142, 2.0]),
+            max_feature_num=tf.constant(1000))
+
+    def match(self, image_a, image_b):
+        image_a = crop_image(image_a)
+        image_b = crop_image(image_b)
+        result_a = self.run_delf(image_a)
+        result_b = self.run_delf(image_b)
+        return match_images(image_a, image_b, result_a, result_b)
+

requirements.txt

@@ -1,3 +1,4 @@
 pillow>=10.0.1
 numpy>=1.23.5
 tensorflow>=2.15.0
+scikit-image>=0.22.0