application

app.py

@@ -0,0 +1,101 @@
+import gradio as gr
+import albumentations as A
+from functions import *
+warnings.filterwarnings('ignore')
+
+
+# transform image
+test_transforms = A.Compose([
+        A.Resize(height=1024, width=1024, always_apply=True),
+        A.Normalize(always_apply=True),
+        ToTensorV2(always_apply=True),])
+
+# select device (whether GPU or CPU)
+device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')
+
+# model loading
+model = torch.load('pickel.pth',map_location=torch.device('cpu'))
+model = model.to(device)
+
+#-> Tuple[Dict, float]
+def predict(img) :
+    
+    # Start a timer
+    start_time = timer()
+    image = np.array(img)
+    h,w,_ = image.shape
+    hw = h*w
+
+    if hw < 2*1024*1024:
+
+        # Transform the target image and add a batch dimension
+        #image_transformed = test_transforms()
+        transformed = test_transforms(image= image)
+        image_transformed = transformed["image"]
+        image_transformed = image_transformed.unsqueeze(0)
+        image_transformed = image_transformed.to(device)
+
+        # inference
+        model.eval()
+        with torch.no_grad():
+            predictions = model(image_transformed)[0]
+
+        nms_prediction = apply_nms(predictions, iou_thresh=0.1)
+
+        pred = plot_img_bbox(image, nms_prediction)
+
+        #pred = np.array(Image.open("pred.jpg"))
+        word = "Number of palm trees detected : "+str(len(nms_prediction["boxes"]))
+        
+        # Calculate the prediction time
+        pred_time = round(timer() - start_time, 5)
+        
+        # Return the prediction dictionary and prediction time 
+        return pred,word
+    
+    else:
+        crop(image)
+        locations = np.load("locations.npy")
+        n = inference(image,locations,model,test_transforms,device)
+        #
+        empty_image = np.zeros(image.shape)
+        del image
+        gc.collect()
+        sleep(1)
+
+        word = "Number of palm trees detected : "+str(n)
+        pred = create_new_ortho(locations,empty_image)
+        # remove files and folders
+        os.remove("locations.npy")
+        shutil.rmtree("images", ignore_errors=True)
+        shutil.rmtree("labels", ignore_errors=True)
+
+        return pred,word
+
+    
+image = gr.components.Image()
+out_im = gr.components.Image()
+out_lab = gr.components.Label()
+
+### 4. Gradio app ###
+# Create title, description and article strings
+title = "🌴Palm trees detection🌴"
+description = "Faster r-cnn model to detect oil palm trees in drones images."
+article = "Created by data354."
+
+# Create examples list from "examples/" directory
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+#[gr.Label(label="Predictions"), # what are the outputs?
+#gr.Number(label="Prediction time (s)")], # our fn has two outputs, therefore we have two outputs
+# Create examples list from "examples/" directory
+# Create the Gradio demo
+demo = gr.Interface(fn=predict, # mapping function from input to output
+                    inputs= image, #gr.Image(type="pil"), # what are the inputs?
+                    outputs=[out_im,out_lab],
+                    examples=example_list, 
+                    title=title,
+                    description=description,
+                    article=article
+                   )
+# Launch the demo!
+demo.launch(debug = False)

functions.py

@@ -0,0 +1,183 @@
+import torch
+import cv2
+import os
+import torch.nn as nn
+import numpy as np
+import torchvision
+from torchvision.ops import box_iou
+from PIL import Image
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import cv2
+import tqdm
+import gc
+from time import sleep
+import shutil
+from timeit import default_timer as timer
+from typing import Tuple, Dict
+import warnings
+warnings.filterwarnings('ignore')
+
+# apply nms algorithm
+def apply_nms(orig_prediction, iou_thresh=0.3):
+        # torchvision returns the indices of the bboxes to keep
+        keep = torchvision.ops.nms(orig_prediction['boxes'], orig_prediction['scores'], iou_thresh)
+        final_prediction = orig_prediction
+        final_prediction['boxes'] = final_prediction['boxes'][keep]
+        final_prediction['scores'] = final_prediction['scores'][keep]
+        final_prediction['labels'] = final_prediction['labels'][keep]
+
+        return final_prediction
+
+
+def apply_nms2(orig_prediction, iou_thresh=0.3):
+        # torchvision returns the indices of the bboxes to keep
+        preds = []
+        for prediction in orig_prediction:
+          keep = torchvision.ops.nms(prediction['boxes'], prediction['scores'], iou_thresh)
+
+          final_prediction = prediction
+          final_prediction['boxes'] = final_prediction['boxes'][keep]
+          final_prediction['scores'] = final_prediction['scores'][keep]
+          final_prediction['labels'] = final_prediction['labels'][keep]
+          preds.append(final_prediction)
+
+        return preds
+
+# Draw the bounding box
+def plot_img_bbox(img, target):
+        h,w,c = img.shape
+        for box in (target['boxes']):
+            xmin, ymin, xmax, ymax  = int((box[0].cpu()/1024)*w), int((box[1].cpu()/1024)*h), int((box[2].cpu()/1024)*w),int((box[3].cpu()/1024)*h)
+            cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 0, 255), 2)
+            label = "palm"
+            # Add the label and confidence score
+            label = f'{label}'
+            cv2.putText(img, label, (xmin, ymin - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
+
+        # Display the image with detections
+        #filename = 'pred.jpg'
+        #cv2.imwrite(filename, img)
+        return img
+
+def crop(image,size=1024):
+    #input = os.path.join(path,image)
+    #img = cv2.imread(input)
+    img = image.copy()
+    H, W,_ = img.shape
+    h = (H//size)
+    w = (W//size)
+    H1 = h*size
+    W1 = w*size
+    os.makedirs("images", exist_ok=True)
+    images = []
+    #images_truth = []
+    locations = []
+
+    if  H1 < H :
+      chevauche_h = H-H1
+      rest_h = 1024-chevauche_h
+      val_h = H1-rest_h
+      H2 = [x for x in range(0,H1,size)] +[val_h]
+    else :
+      H2 = [x for x in range(0,H1,size)]
+
+    if W1 <W :
+      chevauche_w = W-W1
+      rest_w = 1024-chevauche_w
+      val_w = W1-rest_w
+      W2 = [x for x in range(0,W1,size)] +[val_w]
+    else:
+      W2 = [x for x in range(0,W1,size)]
+
+    for i in H2:
+        for j in W2:
+          crop_img = img[i:i+size, j:j+size,:]
+          name = "img_"+str(i)+"_"+str(j)+".png"
+          ## csv file creation
+          location = [i,i+size,j,j+size]
+          locations.append(location)
+          cv2.imwrite(os.path.join("images",name),crop_img)
+          del crop_img
+          gc.collect()
+          #sleep(2)
+    del H
+    del H1
+    del H2
+    del W
+    del W1
+    del W2
+    del h
+    del w
+    gc.collect()
+    sleep(1)
+    np.save("locations.npy",np.array(locations))
+
+def inference(image,locations,model,test_transforms,device):
+    n = 0
+    os.makedirs("labels", exist_ok=True)
+    for i,location in enumerate(locations):
+        name = "img_"+str(location[0])+"_"+str(location[2])+".png"
+        path = os.path.join("images",name)
+        imgs = np.array(cv2.imread(path))
+        transformed = test_transforms(image= imgs)
+        image_transformed = transformed["image"]
+        image_transformed = image_transformed.unsqueeze(0)
+        image_transformed = image_transformed.to(device)
+
+        model.eval()
+        with torch.no_grad():
+            predictions = model(image_transformed)
+
+        del imgs
+        del name
+        del path
+        del transformed
+        del image_transformed
+        gc.collect()
+        sleep(1)
+
+        nms_prediction = apply_nms2(predictions, iou_thresh=0.1)
+        img = image[location[0]:location[1],location[2]:location[3],:]
+        n = n+len(nms_prediction[0]['boxes'])
+
+        for box in (nms_prediction[0]['boxes']):
+            xmin, ymin, xmax, ymax = int(box[0].cpu()), int(box[1].cpu()), int(box[2].cpu()),int(box[3].cpu())
+            cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (255, 0, 0), 2)
+            label = "palm"
+            # Add the label and confidence score
+            label = f'{label}'
+            cv2.putText(img, label, (xmin, ymin - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
+            del label
+        #empty_image[location[0]:location[1],location[2]:location[3],:] = img
+        label_name = "lab_"+str(location[0])+"_"+str(location[2])+".png"
+        cv2.imwrite(os.path.join("labels",label_name),img)
+
+        del label_name
+        del img
+        del nms_prediction
+        del predictions
+        gc.collect()
+        sleep(1)
+
+    return n
+
+def create_new_ortho(locations,empty_image):
+    for i,location in tqdm(enumerate(locations),total=len(locations)):
+        name = "lab_"+str(location[0])+"_"+str(location[2])+".png"
+        path = os.path.join("labels",name)
+        img = np.array(cv2.imread(path))
+        empty_image[location[0]:location[1],location[2]:location[3],:] = img
+        if i%300==0:
+            cv2.imwrite("img.png",empty_image)
+            del img
+            del name
+            del path
+            del empty_image
+            gc.collect()
+            #sleep(1)
+            empty_image = np.array(cv2.imread("img.png"))
+
+    cv2.imwrite("img.png",empty_image)
+    empty_image = np.array(cv2.imread("img.png"))
+    return empty_image