Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,12 @@ 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
+building_segmentation_model.keras filter=lfs diff=lfs merge=lfs -text
+images/22678945_15.png filter=lfs diff=lfs merge=lfs -text
+images/22828930_15.png filter=lfs diff=lfs merge=lfs -text
+images/23429080_15.png filter=lfs diff=lfs merge=lfs -text
+images/23729035_15.png filter=lfs diff=lfs merge=lfs -text
+images/24179065_15.png filter=lfs diff=lfs merge=lfs -text
+mask.png filter=lfs diff=lfs merge=lfs -text
+mask2.png filter=lfs diff=lfs merge=lfs -text
+task_definition.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,28 @@
 ---
-title: Building Footprint Segmentation
-emoji: 🏢
-colorFrom: indigo
-colorTo: red
+title: building_footprint_segmentation
+app_file: demo.py
 sdk: gradio
 sdk_version: 4.24.0
-app_file: app.py
-pinned: false
 ---
+A U-Net model for segmenting buildings from satellite imagery
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+A binary segmentation mask (of the same height and width with the input image) should be created The segmentation mask should have a value of 1 at pixels where there is a building and 0 at other pixels.
+
+The figure below showcases the input and output image expected. In the mask pixels that correspond to pixels in the input image are white and background is black.
+
+![Expected input and output](images/task_definition.png)
+
+# Data
+The data used in this project is sourced from [Road and Building Detection Datasets](https://www.cs.toronto.edu/~vmnih/data/) with the following citation:
+
+```
+@phdthesis{MnihThesis,
+    author = {Volodymyr Mnih},
+    title = {Machine Learning for Aerial Image Labeling},
+    school = {University of Toronto},
+    year = {2013}
+}
+
+```
+
+For the ease of use, relevant parts of this dataset was sourced from [kaggle.com](https://www.kaggle.com/datasets/balraj98/massachusetts-buildings-dataset)

building_segmentation_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:468bf3edbc57bff66868ca0dc86d351f7a6f938c80f4c20b7e4da7fc5058a74d
+size 89891608

demo.py

@@ -0,0 +1,36 @@
+import numpy as np
+import utils
+from keras.models import load_model
+import matplotlib.pyplot as plt
+import gradio as gr
+
+model = load_model("building_segmentation_model.keras")
+
+def segment(img):
+    mask = utils.predict(model, img)
+    mask = mask[..., 0]
+    
+    # Set masked regions to blue with 70% transparency
+    blue_color = np.array([255, 0, 0], dtype=np.uint8)  # Red color
+    transparency = 0.7
+    
+    masked_image = img.copy()
+    masked_image[mask == 1] = masked_image[mask == 1] * (1 - transparency) +  transparency * blue_color
+    
+    return masked_image
+
+demo = gr.Interface(
+    fn = segment,
+    inputs=[gr.Image()],
+    outputs=[gr.Image()],
+    examples=[
+        "images/22678945_15.png",
+        "images/22828930_15.png",
+        "images/23429080_15.png",
+        "images/23729035_15.png",
+        "images/24179065_15.png",
+    ]
+)
+
+if __name__ == "__main__":
+    demo.launch() 

requirements.txt

@@ -0,0 +1,6 @@
+gradio==4.24.0
+keras==2.15.0
+matplotlib==3.7.1
+matplotlib==3.5.1
+numpy==1.23.5
+numpy==1.21.5

utils.py

@@ -0,0 +1,75 @@
+import numpy as np
+import math
+
+def calculate_padding(image, patch_size=256):
+  """
+    Calculates required padding amounts
+
+    ARGS:
+      image: Image to be padded (height, width, channels)
+      patch_size: Stride of the patches
+
+    RETURNS:
+      padding: Padding amounts (top, bottom, left, right)
+  """
+
+  height, width = image.shape[-3:-1]
+
+  # Calculate Desired shape
+  xx = (width // patch_size +1) * patch_size
+  yy = (height // patch_size +1) * patch_size
+
+  # Calculate padding amounts
+  x_pad = xx - width
+  y_pad = yy - height
+
+  x0 = x_pad // 2
+  x1 = x_pad - x0
+  y0 = y_pad // 2
+  y1 = y_pad - y0
+
+  return (y0, y1, x0, x1)
+
+def apply_padding(image, patch_size=256):
+  """
+    Adds padding to the image to make patches of equal size that covers the entire image
+
+    ARGS:
+      image: Image to be padded
+      patch_size: Stride of the patches
+
+    RETURNS:
+      padded_image: Padded image
+  """
+  width, height = image.shape[:2]
+  pad_y0, pad_y1, pad_x0, pad_x1 = calculate_padding(image, patch_size)
+
+  return np.pad(image, ((pad_y0, pad_y1), (pad_x0, pad_x1), (0, 0)), mode='constant')
+
+
+def predict(model, img, threshold=0.5, patch_size=256):
+  """
+    model: a keras model
+    img: a np array representing the image (expects float dtype and values between 0 and 1)
+  """
+  padded = apply_padding(img, patch_size)
+
+  number_of_rows, number_of_columns = math.ceil(img.shape[0] /patch_size), math.ceil(img.shape[1] /patch_size)
+  # fig, axes = plt.subplots(number_of_rows, number_of_columns, figsize=(20, 20))
+  prediction = np.zeros((number_of_rows * patch_size, number_of_columns * patch_size, 1), dtype="float32")
+
+  for i in range(0, number_of_rows):
+    for j in range(0, number_of_columns):
+      # Convert to float
+      slc = padded[i*patch_size:(i+1)*patch_size, j*patch_size:(j+1)*patch_size] / 256.0
+      pred = model.predict(np.expand_dims(slc, axis = 0), verbose = 0)
+      # axes[i][j].imshow(pred[0])
+      prediction[i*patch_size:(i+1)*patch_size, j*patch_size:(j+1)*patch_size] = pred[0]
+
+  # Threshold the results
+  prediction = (prediction > threshold).astype(np.uint8)
+
+  # Reverse padding
+  y0, y1, x0, x1 = calculate_padding(img, patch_size)
+  preds = prediction[y0:-y1, x0:-x1]
+  return preds