basic func

app.py

@@ -1,18 +1,67 @@
 import gradio as gr
 
-def detr(im):
-    return im
+from layers import BilinearUpSampling2D
+import matplotlib.pyplot as plt
+import numpy as np
+
+from huggingface_hub import from_pretrained_keras
+
+custom_objects = {'BilinearUpSampling2D': BilinearUpSampling2D, 'depth_loss_function': None}
+print('Loading model...')
+model = from_pretrained_keras("keras-io/monocular-depth-estimation", custom_objects=custom_objects, compile=False)
+print('Successfully loaded model...')
+
+import importlib
+import utils
+importlib.reload(utils)
+
+def infer(image, min_th, max_th):
+    print('_'*20)
+    inputs = utils.load_images([image])
+    outputs = utils.predict(model, inputs)
+
+    plasma = plt.get_cmap('plasma')
+    rescaled = outputs[0][:, :, 0]
+    print("Min Max Bef", np.min(rescaled), np.max(rescaled))
+    rescaled = rescaled - np.min(rescaled)
+    rescaled = rescaled / np.max(rescaled)
+
+    image_out = plasma(rescaled)[:, :, :3]
+
+    print("Min Max Aft", np.min(rescaled), np.max(rescaled))
+
+    print("Shape Scaled:",rescaled.shape)
+    filtered = rescaled
+    # filtered[filtered[:, :, 0] < min_th/100, 0] = 0
+    # filtered[filtered[:, :, 0] < min_th/100, 1] = 0
+    # filtered[filtered[:, :, 0] < min_th/100, 2] = 0
+    # filt_arr = filtered[((filtered[:,0] > min_th/100) & (filtered[:,0] < max_th/100))]
+    filt_arr = (filtered > min_th/100) * filtered * (filtered < max_th/100)
+
+
+    print("Shape Image:",image.shape)
+    print("Shape Image filt:",im_filt.shape)
+    print("Shape Image Heat:",image_out.shape)
+    im_filt = plasma(filt_arr)[:, :, :3]
+    return image_out, im_filt, image
+
+# def detr(im):
+#     return im
 
 gr_input = [
-    gr.inputs.Image(type='pil', label="Original Image")
+    gr.inputs.Image(label="image", type="numpy", shape=(640, 480))
+    ,gr.inputs.Slider(minimum=0, maximum=100, step=5, default=0, label="Minimum Threshold")
+    ,gr.inputs.Slider(minimum=0, maximum=100, step=5, default=100, label="Maximum Threshold")
 ]
 
 gr_output = [
+    gr.outputs.Image(type="pil",label="HeatMap Image"),
+    gr.outputs.Image(type="pil",label="Filtered Image"),
     gr.outputs.Image(type="pil",label="Output Image")
 ]
 
 iface = gr.Interface(
-    fn=detr,
+    fn=infer,
     title="Space Title Here",
     description = "Description Here",
     inputs  = gr_input,

layers.py

@@ -0,0 +1,55 @@
+from tensorflow.keras.layers import Layer, InputSpec
+import keras.utils.conv_utils as conv_utils
+import tensorflow as tf
+import tensorflow.keras.backend as K
+
+
+def normalize_data_format(value):
+    if value is None:
+        value = K.image_data_format()
+    data_format = value.lower()
+    if data_format not in {'channels_first', 'channels_last'}:
+        raise ValueError('The `data_format` argument must be one of '
+                         '"channels_first", "channels_last". Received: ' +
+                         str(value))
+    return data_format
+
+
+class BilinearUpSampling2D(Layer):
+    def __init__(self, size=(2, 2), data_format=None, **kwargs):
+        super(BilinearUpSampling2D, self).__init__(**kwargs)
+        self.data_format = normalize_data_format(data_format)
+        self.size = conv_utils.normalize_tuple(size, 2, 'size')
+        self.input_spec = InputSpec(ndim=4)
+
+    def compute_output_shape(self, input_shape):
+        if self.data_format == 'channels_first':
+            height = self.size[0] * input_shape[2] if input_shape[2] is not None else None
+            width = self.size[1] * input_shape[3] if input_shape[3] is not None else None
+            return (input_shape[0],
+                    input_shape[1],
+                    height,
+                    width)
+        elif self.data_format == 'channels_last':
+            height = self.size[0] * input_shape[1] if input_shape[1] is not None else None
+            width = self.size[1] * input_shape[2] if input_shape[2] is not None else None
+            return (input_shape[0],
+                    height,
+                    width,
+                    input_shape[3])
+
+    def call(self, inputs):
+        input_shape = K.shape(inputs)
+        if self.data_format == 'channels_first':
+            height = self.size[0] * input_shape[2] if input_shape[2] is not None else None
+            width = self.size[1] * input_shape[3] if input_shape[3] is not None else None
+        elif self.data_format == 'channels_last':
+            height = self.size[0] * input_shape[1] if input_shape[1] is not None else None
+            width = self.size[1] * input_shape[2] if input_shape[2] is not None else None
+
+        return tf.image.resize(inputs, [height, width], method=tf.image.ResizeMethod.BILINEAR)
+
+    def get_config(self):
+        config = {'size': self.size, 'data_format': self.data_format}
+        base_config = super(BilinearUpSampling2D, self).get_config()
+        return dict(list(base_config.items()) + list(config.items()))

utils.py

@@ -0,0 +1,25 @@
+import numpy as np
+
+
+def depth_norm(x, maxDepth):
+    return maxDepth / x
+
+
+def predict(model, images, minDepth=10, maxDepth=1000, batch_size=2):
+    # Support multiple RGBs, one RGB image, even grayscale
+    if len(images.shape) < 3: images = np.stack((images, images, images), axis=2)
+    if len(images.shape) < 4: images = images.reshape((1, images.shape[0], images.shape[1], images.shape[2]))
+    # Compute predictions
+    predictions = model.predict(images, batch_size=batch_size)
+    # Put in expected range
+    print("Max Depth:", np.amax(predictions), maxDepth)
+    print("Min Depth:", np.amin(predictions), minDepth)
+    return np.clip(depth_norm(predictions, maxDepth=maxDepth), minDepth, maxDepth) / maxDepth
+
+
+def load_images(image_files):
+    loaded_images = []
+    for file in image_files:
+        x = np.clip(file.reshape(480, 640, 3) / 255, 0, 1)
+        loaded_images.append(x)
+    return np.stack(loaded_images, axis=0)