adding tiling + dataframe output

app.py

@@ -1,7 +1,8 @@
 import gradio as gr
 from models import yolo
-from cv2 import  rectangle, putText, FONT_HERSHEY_SIMPLEX, applyColorMap, COLORMAP_HSV
+from cv2 import  COLOR_BGR2RGB, imread, cvtColor
 import numpy as np
+import pandas as pd
 
 
 
@@ -10,26 +11,67 @@ with open("eggs.names") as f:
     classes = f.read().split("\n")
 
 num_classes = len(classes)
-palette = np.arange(0, 255, dtype=np.uint8).reshape(1, 255, 1)
-palette = applyColorMap(palette, COLORMAP_HSV).squeeze(0)
-np.random.shuffle(palette)
+
+# stitched_h = 1
+# stitched_v = 1
+# magnification_reduction = 2.5
+
+# h_mag_factor = int(stitched_h * magnification_reduction) #e.g. 6
+# v_mag_factor = int(stitched_v * magnification_reduction) #e.g. 8
+
 
 classifier = yolo("yolov4-eggs.cfg", "yolov4-eggs_best.weights", classes)
 
-def classify(img):
-    predictions = classifier.run_inference(img)
+def classify(img_path, h_tiles, v_tiles):
     
-    for (x,y,w,h, confidence, label, classID) in predictions:
-        #print(label)
-        rectangle(img, (x, y), (x + w, y + h), tuple(palette[classID].tolist()), 2)
-        text = "{}: {:.2f}".format(label, confidence)
-        putText(img, text, (x, y - 5), FONT_HERSHEY_SIMPLEX, 0.5, tuple(palette[classID].tolist()), 1)
-        # for (value,key) in zip([name, x,y,w,h, confidence, label, classID], detections.keys()):
-        #     detections[key].append(value)
-    return img
+    img = imread(img_path)
+    #so we need to break the full image up into h_mag_factor by v_mag_factor subimages
+    
+    h_splits = np.array_split(img, h_tiles)
+
+    
+    h_offset = 0
+    output = img.copy()
+    detections = []
+    for h_split in h_splits:
+        v_offset = 0
+        #split this horizontal strip vertically
+        v_splits = np.array_split(h_split, v_tiles, axis =1)
+        for split in v_splits:
+            predictions = classifier.run_inference(split, h_offset, v_offset)
+            #print(len(prediction))
+            
+            output = classifier.show_predictions(predictions, output)
+            #add to the vertical offset 
+            v_offset += split.shape[1]
+            
+            detections.extend(predictions)
+
+
+        #add the width of this split to the horizontal offset
+        h_offset += h_split.shape[0]
+    detections = pd.DataFrame(detections, columns = ["x", "y", "h", "w", "confidence", "class", "class id"])
+    return cvtColor(output, COLOR_BGR2RGB), detections
         
-def greet(name):
-    return "Hello " + name + "!!"
+description = """
+    Demonstration of kelp sporophyte object detection network. 
+    
+    The tiling sliders control the amount of horizontal and vertical tiling
+    applied to the image. Training images were taken at 100x magnification 
+    (10x microscope lens x 10x lense), so the tiling can be used to match input
+    image scale to the training data scale, which generally improves performance.
+    For example, to detect objects in an image taken at 40x, try using 2-3
+    horizontal and vertical tiles. 
 
-iface = gr.Interface(classify, gr.Image(shape=(896, 684)), "image", examples = ["ex1.jpg", "ex2.jpg", "ex3.jpg", "ex4.jpg"])
+"""
+iface = gr.Interface(fn = classify,
+    inputs = [gr.Image(type="filepath"), gr.Slider(minimum=1, maximum=10, value=1, step=1), 
+        gr.Slider(minimum=1, maximum=10, value=1, step=1)],
+    outputs = [gr.Image(invert_colors=False), gr.DataFrame()],
+    examples = [["ex1.jpg", 1, 1],
+        ["ex2.jpg", 1, 1],
+        ["ex3.jpg", 1, 1],
+        ["ex4.jpg", 1, 1],
+        ["sporo_40x.jpg", 2, 2]],
+        description=description)
 iface.launch()

models.py

@@ -16,11 +16,28 @@ class yolo:
         self.classes = classes
         self.confidence_threshold = confidence_threshold
 
-    def run_inference(self, img):
+        #palette for drawing on images 
+        palette = np.arange(0, 255, dtype=np.uint8).reshape(1, 255, 1)
+        palette = cv.applyColorMap(palette, cv.COLORMAP_HSV).squeeze(0)
+        np.random.shuffle(palette)
+        self.palette = palette
+    def show_predictions(self, predictions, input):
+        img = input.copy()
+        for (x,y,w,h, confidence, label, classID) in predictions:
+            #print(label)
+           
+            cv.rectangle(img, (x, y), (x + w, y + h), tuple(self.palette[classID].tolist()), 2)
+            text = "{}: {:.2f}".format(label, confidence)
+            cv.putText(img, text, (x, y - 5), cv.FONT_HERSHEY_SIMPLEX, 0.5, tuple(self.palette[classID].tolist()), 1)
+            # for (value,key) in zip([name, x,y,w,h, confidence, label, classID], detections.keys()):
+            #     detections[key].append(value)
+        return img
+
+    def run_inference(self, img, h_offset, v_offset):
         """forward pass on a list of images
 
             returns: list of predictions in the format
-            [(-1, 311, 198, 59, 0.8714446425437927, 'Sporophyte'), (215, 47, 199, 258, 0.8504674434661865, 'Sporophyte')] 
+            [(x, y, w, h, conf, class),..] e.g. [ (215, 47, 199, 258, 0.8504674434661865, 'Sporophyte')] 
         """
 
 
@@ -69,7 +86,7 @@ class yolo:
                 (w, h) = (boxes[i][2], boxes[i][3])
                 label = self.classes[classIDs[i]]
                 confidence = confidences[i]
-                outputs.append((x,y,w,h,confidence,label, classIDs[i]))
+                outputs.append((x + v_offset,y + h_offset,w,h,confidence,label, classIDs[i]))
         return outputs
         """
         colors = np.random.randint(0, 255, size=(len(classes), 3), dtype='uint8')