resize to (1500, 1500)

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

app.py

@@ -13,8 +13,56 @@ np.random.seed(12345)
 
 device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
 
+def find_contours(img, color):
+    low = color - 10
+    high = color + 10
+
+    mask = cv2.inRange(img, low, high)
+    contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+    print(f"Total Contours: {len(contours)}")
+    nonempty_contours = list()
+    for i in range(len(contours)):
+        if hierarchy[0,i,3] == -1 and cv2.contourArea(contours[i]) > cv2.arcLength(contours[i], True):
+            nonempty_contours += [contours[i]]
+    print(f"Nonempty Contours: {len(nonempty_contours)}")
+    contour_plot = img.copy()
+    contour_plot = cv2.drawContours(contour_plot, nonempty_contours, -1, (0,255,0), -1)
+
+    sorted_contours = sorted(nonempty_contours, key=cv2.contourArea, reverse= True)
+
+    bounding_rects = [cv2.boundingRect(cnt) for cnt in contours]
+
+    for (i,c) in enumerate(sorted_contours):
+        M= cv2.moments(c)
+        cx= int(M['m10']/M['m00'])
+        cy= int(M['m01']/M['m00'])
+        cv2.putText(contour_plot, text= str(i), org=(cx,cy),
+                fontFace= cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.25, color=(255,255,255),
+                thickness=1, lineType=cv2.LINE_AA)
+
+    N = len(sorted_contours)
+    H, W, C = img.shape
+    boxes_array_xywh = [cv2.boundingRect(cnt) for cnt in sorted_contours]
+    boxes_array_corners = [[x, y, x+w, y+h] for x, y, w, h in boxes_array_xywh]
+    boxes = torch.tensor(boxes_array_corners)
+
+    labels = torch.ones(N)
+    masks = np.zeros([N, H, W])
+    for idx in range(len(sorted_contours)):
+        cnt = sorted_contours[idx]
+        cv2.drawContours(masks[idx,:,:], [cnt], 0, (255), -1)
+    masks = masks / 255.0
+    masks = torch.tensor(masks)
+
+    # for box in boxes:
+    #     cv2.rectangle(contour_plot, (box[0].item(), box[1].item()), (box[2].item(), box[3].item()), (255,0,0), 2)
+
+    return contour_plot, (boxes, masks)
+
+
 def get_dataset_x(blank_image, filter_size=50, filter_stride=2):
-    full_image_tensor = blank_image.type(torch.FloatTensor).unsqueeze(0)
+    full_image_tensor = torch.tensor(blank_image).type(torch.FloatTensor).permute(2, 0, 1).unsqueeze(0)
     num_windows_h = math.floor((full_image_tensor.shape[2] - filter_size) / filter_stride) + 1
     num_windows_w = math.floor((full_image_tensor.shape[3] - filter_size) / filter_stride) + 1
     windows = torch.nn.functional.unfold(full_image_tensor, (filter_size, filter_size), stride=filter_stride).reshape(
@@ -25,6 +73,51 @@ def get_dataset_x(blank_image, filter_size=50, filter_stride=2):
     return dataset
 
 
+def get_dataset(labeled_image, blank_image, color, filter_size=50, filter_stride=2, label_size=5):
+    contour_plot, (blue_boxes, blue_masks) = find_contours(labeled_image, color)
+
+    mask = torch.sum(blue_masks, 0)
+
+    label_dim = int((labeled_image.shape[0] - filter_size) / filter_stride + 1)
+    labels = torch.zeros(label_dim, label_dim)
+    mask_labels = torch.zeros(label_dim, label_dim, filter_size, filter_size)
+
+    for lx in range(label_dim):
+        for ly in range(label_dim):
+            mask_labels[lx, ly, :, :] = mask[
+                                        lx * filter_stride: lx * filter_stride + filter_size,
+                                        ly * filter_stride: ly * filter_stride + filter_size
+                                        ]
+
+    print(labels.shape)
+    for box in blue_boxes:
+        x = int((box[0] + box[2]) / 2)
+        y = int((box[1] + box[3]) / 2)
+
+        window_x = int((x - int(filter_size / 2)) / filter_stride)
+        window_y = int((y - int(filter_size / 2)) / filter_stride)
+
+        clamp = lambda n, minn, maxn: max(min(maxn, n), minn)
+
+        labels[
+        clamp(window_y - label_size, 0, labels.shape[0] - 1):clamp(window_y + label_size, 0, labels.shape[0] - 1),
+        clamp(window_x - label_size, 0, labels.shape[0] - 1):clamp(window_x + label_size, 0, labels.shape[0] - 1),
+        ] = 1
+
+    positive_labels = labels.flatten() / labels.max()
+    negative_labels = 1 - positive_labels
+    pos_mask_labels = torch.flatten(mask_labels, end_dim=1)
+    neg_mask_labels = 1 - pos_mask_labels
+    mask_labels = torch.stack([pos_mask_labels, neg_mask_labels], dim=1)
+    dataset_labels = torch.tensor(list(zip(positive_labels, negative_labels)))
+    dataset = list(zip(
+        get_dataset_x(blank_image, filter_size=filter_size, filter_stride=filter_stride),
+        dataset_labels,
+        mask_labels
+    ))
+    return dataset, (labels, mask_labels)
+
+
 from torchvision.models.resnet import resnet50
 from torchvision.models.resnet import ResNet50_Weights
 
@@ -39,7 +132,7 @@ model.to(device)
 import gradio as gr
 
 
-def count_barnacles(raw_input_img, progress=gr.Progress()):
+def count_barnacles(raw_input_img, labeled_input_img, progress=gr.Progress()):
     progress(0, desc="Finding bounding wire")
 
     # crop image
@@ -91,7 +184,11 @@ def count_barnacles(raw_input_img, progress=gr.Progress()):
     label_img /= label_img.max()
     label_img = (label_img * 255).astype(np.uint8)
     mask = np.array(label_img > 180, np.uint8)
-    contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    contours, hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\
+
+    gt_contours = find_contours(labeled_input_img[x:x+w, y:y+h], cropped_img, np.array([59, 76, 160]))
+
+
 
     def extract_contour_center(cnt):
         M = cv2.moments(cnt)
@@ -117,7 +214,16 @@ def count_barnacles(raw_input_img, progress=gr.Progress()):
     return blank_img_copy, len(points)
 
 
-demo = gr.Interface(count_barnacles, gr.Image(shape=(500, 500), type="numpy"),
-                    outputs=[gr.Image(shape=(500, 500), type="numpy", label="Annotated Image"), gr.Number(label="Number of Barnacles")])
+demo = gr.Interface(count_barnacles,
+                    inputs=[
+                        gr.Image(shape=(500, 500), type="numpy", label="Input Image"),
+                        gr.Image(shape=(500, 500), type="numpy", label="Masked Input Image")
+                    ],
+                    outputs=[
+                        gr.Image(shape=(500, 500), type="numpy", label="Annotated Image"),
+                        gr.Number(label="Predicted Number of Barnacles"),
+                        gr.Number(label="Actual Number of Barnacles"),
+                        gr.Number(label="Custom Metric")
+                    ])
                     # examples="examples")
 demo.queue(concurrency_count=10).launch()