Add aggregation, add app2, fix codecov, standardize globals

.codecov.yml

@@ -3,8 +3,7 @@ codecov:
 
 ignore:
   - "app.py"
-  - "scoutbot/*/convert.py"       # wildcards accepted
-  - "**/*.py"         # glob accepted
+  - "scoutbot/*/convert.py"
 
 coverage:
   status:

.gitignore

@@ -4,6 +4,7 @@ output.*.jpg
 
 *.egg-info/
 
+examples/*_w_256_h_256.jpg
 .coverage
 coverage/
 

app.py

@@ -7,44 +7,47 @@ from scoutbot import loc, wic
 
 
 def predict(filepath, wic_thresh, loc_thresh, nms_thresh):
+    wic_thresh /= 100.0
+    loc_thresh /= 100.0
+    nms_thresh /= 100.0
+
     # Load data
     img = cv2.imread(filepath)
     img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
     inputs = [filepath]
 
-    wic_thresh /= 100.0
-    loc_thresh /= 100.0
-    nms_thresh /= 100.0
-
     # Run WIC
     outputs = wic.post(wic.predict(wic.pre(inputs)))
-    output = outputs[0]
 
     # Get WIC confidence
+    output = outputs[0]
     wic_confidence = output.get('positive')
 
-    # Run Localizer
-
     loc_detections = []
     if wic_confidence > wic_thresh:
+
+        # Run Localizer
         data, sizes = loc.pre(inputs)
         preds = loc.predict(data)
         outputs = loc.post(preds, sizes, loc_thresh=loc_thresh, nms_thresh=nms_thresh)
-        detects = outputs[0]
 
+        # Format and render results
+        detects = outputs[0]
         for detect in detects:
-            if detect.confidence >= loc_thresh:
+            label = detect['l']
+            conf = detect['c']
+            if conf >= loc_thresh:
                 point1 = (
-                    int(np.around(detect.x_top_left)),
-                    int(np.around(detect.y_top_left)),
+                    int(np.around(detect['x'])),
+                    int(np.around(detect['y'])),
                 )
                 point2 = (
-                    int(np.around(detect.x_top_left + detect.width)),
-                    int(np.around(detect.y_top_left + detect.height)),
+                    int(np.around(detect['x'] + detect['w'])),
+                    int(np.around(detect['y'] + detect['h'])),
                 )
                 color = (255, 0, 0)
                 img = cv2.rectangle(img, point1, point2, color, 2)
-                loc_detections.append(f'{detect.class_label}: {detect.confidence:0.04f}')
+                loc_detections.append(f'{label}: {conf:0.04f}')
     loc_detections = '\n'.join(loc_detections)
 
     return img, wic_confidence, loc_detections
@@ -52,7 +55,7 @@ def predict(filepath, wic_thresh, loc_thresh, nms_thresh):
 
 interface = gr.Interface(
     fn=predict,
-    title='Scout Demo',
+    title='Wild Me Scout - Tile ML Demo',
     inputs=[
         gr.Image(type='filepath'),
         gr.Slider(label='WIC Confidence Threshold', value=20),

app2.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+import time
+
+import cv2
+import gradio as gr
+import numpy as np
+
+import scoutbot
+
+
+def predict(filepath, wic_thresh, loc_thresh, agg_thresh, loc_nms_thresh, agg_nms_thresh):
+    start = time.time()
+
+    wic_thresh /= 100.0
+    loc_thresh /= 100.0
+    loc_nms_thresh /= 100.0
+    agg_thresh /= 100.0
+    agg_nms_thresh /= 100.0
+
+    # Load data
+    img = cv2.imread(filepath)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+    h, w, c = img.shape
+    pixels = h * w
+    megapixels = pixels / 1e6
+
+    detects = scoutbot.pipeline(
+        filepath, wic_thresh, loc_thresh, loc_nms_thresh, agg_thresh, agg_nms_thresh
+    )
+
+    output = []
+    for detect in detects:
+        label = detect['l']
+        conf = detect['c']
+        if conf >= loc_thresh:
+            point1 = (
+                int(np.around(detect['x'])),
+                int(np.around(detect['y'])),
+            )
+            point2 = (
+                int(np.around(detect['x'] + detect['w'])),
+                int(np.around(detect['y'] + detect['h'])),
+            )
+            color = (255, 0, 0)
+            img = cv2.rectangle(img, point1, point2, color, 2)
+            output.append(f'{label}: {conf:0.04f}')
+    output = '\n'.join(output)
+
+    end = time.time()
+    duration = end - start
+    speed = duration / megapixels
+    speed = f'{speed:0.02f} seconds per megapixel (total: {megapixels:0.02f} megapixels, {duration:0.02f} seconds)'
+
+    return img, speed, output
+
+
+interface = gr.Interface(
+    fn=predict,
+    title='Wild Me Scout - Image ML Demo',
+    inputs=[
+        gr.Image(type='filepath'),
+        gr.Slider(label='WIC Confidence Threshold', value=20),
+        gr.Slider(label='Localizer Confidence Threshold', value=48),
+        gr.Slider(label='Aggregation Confidence Threshold', value=51),
+        gr.Slider(label='Localizer NMS Threshold', value=20),
+        gr.Slider(label='Aggregation NMS Threshold', value=20),
+    ],
+    outputs=[
+        gr.Image(type='numpy'),
+        gr.Textbox(label='Prediction Speed', interactive=False),
+        gr.Textbox(label='Predicted Detections', interactive=False),
+    ],
+    examples=[
+        ['examples/0d4e4df2-7b69-91b1-1985-c8421f2f3253.jpg', 20, 48, 51, 20, 20],
+        ['examples/18cef191-74ed-2b5e-55a5-f58bd3d483ff.jpg', 10, 48, 51, 20, 20],
+        ['examples/1be4d40a-6fd0-42ce-da6c-294e45781f41.jpg', 20, 48, 51, 20, 20],
+        ['examples/1d3c85e9-ee24-f290-e7e1-6e338f2eaebb.jpg', 20, 48, 51, 20, 20],
+        ['examples/3e043302-af1c-75a7-4057-3a2f25c123bf.jpg', 20, 48, 51, 20, 20],
+        ['examples/43ecc08d-502a-7a51-9d68-3e40a76439a2.jpg', 20, 48, 51, 20, 20],
+        ['examples/479058af-e774-e6aa-a2b0-9a42dd6ff8b1.jpg', 20, 48, 51, 20, 20],
+        ['examples/7c910b87-ae3a-f580-d431-03cd89793803.jpg', 20, 48, 51, 20, 20],
+        ['examples/8fa04489-cd94-7d8f-7e2e-5f0fe2f7ae76.jpg', 20, 48, 51, 20, 20],
+        ['examples/bb7b4345-b98a-c727-4c94-6090f0aa4355.jpg', 20, 48, 51, 20, 20],
+    ],
+    cache_examples=True,
+    allow_flagging='never',
+)
+
+interface.launch(server_name='0.0.0.0')

scoutbot/__init__.py

@@ -1,7 +1,88 @@
 # -*- coding: utf-8 -*-
 '''
-2022 Wild Me
+ScoutBot is the machine learning interface for the Wild Me Scout project.
+
+Notes:
+    detection_config = {
+        'algo': 'tile_aggregation',
+        'config_filepath': 'variant3-32',
+        'weight_filepath': 'densenet+lightnet;scout-5fbfff26-boost3,0.400,scout_5fbfff26_v0,0.4',
+        'nms_thresh': 0.8,
+        'sensitivity': 0.5077,
+    }
+
+    (
+        wic_model_tag,
+        wic_thresh,
+        weight_filepath,
+        nms_thresh,
+    ) = 'scout-5fbfff26-boost3,0.400,scout_5fbfff26_v0,0.4'
+
+
+    wic_confidence_list = ibs.scout_wic_test(
+        gid_list, classifier_algo='densenet', model_tag=wic_model_tag
+    )
+    config = {
+        'grid': False,
+        'algo': 'lightnet',
+        'config_filepath': weight_filepath,
+        'weight_filepath': weight_filepath,
+        'nms': True,
+        'nms_thresh': nms_thresh,
+        'sensitivity': 0.0,
+    }
+    prediction_list = depc.get_property(
+        'localizations', gid_list_, None, config=config
+    )
 '''
+from scoutbot import agg, loc, tile, wic
+
 VERSION = '0.1.0'
 version = VERSION
 __version__ = VERSION
+
+
+def fetch(pull=False):
+    wic.fetch(pull=pull)
+    loc.fetch(pull=pull)
+
+
+def pipeline(
+    filepath,
+    wic_thresh=wic.WIC_THRESH,
+    loc_thresh=loc.LOC_THRESH,
+    loc_nms_thresh=loc.NMS_THRESH,
+    agg_thresh=agg.AGG_THRESH,
+    agg_nms_thresh=agg.NMS_THRESH,
+):
+    import utool as ut
+
+    # Run tiling
+    img_shape, tile_grids, tile_filepaths = tile.compute(filepath)
+
+    # Run WIC
+    wic_outputs = wic.post(wic.predict(wic.pre(tile_filepaths)))
+
+    # Threshold for WIC
+    flags = [wic_output.get('positive') >= wic_thresh for wic_output in wic_outputs]
+    loc_tile_grids = ut.compress(tile_grids, flags)
+    loc_tile_filepaths = ut.compress(tile_filepaths, flags)
+
+    # Run localizer
+    loc_data, loc_sizes = loc.pre(loc_tile_filepaths)
+    loc_preds = loc.predict(loc_data)
+    loc_outputs = loc.post(
+        loc_preds, loc_sizes, loc_thresh=loc_thresh, nms_thresh=loc_nms_thresh
+    )
+    assert len(loc_tile_grids) == len(loc_outputs)
+
+    # Run Aggregation
+    detects = agg.compute(
+        img_shape,
+        loc_tile_grids,
+        loc_outputs,
+        agg_thresh=agg_thresh,
+        nms_thresh=agg_nms_thresh,
+    )
+
+    return detects

scoutbot/agg/__init__.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+'''
+2022 Wild Me
+'''
+import numpy as np
+import utool as ut
+
+MARGIN = 32.0
+AGG_THRESH = 0.4
+NMS_THRESH = 0.2
+
+
+def iou(box1, box2):
+    inter_xtl = max(box1['xtl'], box2['xtl'])
+    inter_ytl = max(box1['ytl'], box2['ytl'])
+    inter_xbr = min(box1['xbr'], box2['xbr'])
+    inter_ybr = min(box1['ybr'], box2['ybr'])
+
+    inter_w = inter_xbr - inter_xtl
+    inter_h = inter_ybr - inter_ytl
+
+    if inter_w <= 0 or inter_h <= 0:
+        inter = 0.0
+    else:
+        inter_w = max(0.0, inter_xbr - inter_xtl)
+        inter_h = max(0.0, inter_ybr - inter_ytl)
+        inter = inter_w * inter_h
+
+    area1 = box1['w'] * box1['h']
+    area2 = box2['w'] * box2['h']
+
+    union = area1 + area2 - inter
+
+    return area1, area2, inter, union
+
+
+def demosaic(img_shape, tile_grids, loc_outputs, margin=MARGIN):
+    assert len(tile_grids) == len(loc_outputs)
+
+    img_h, img_w = img_shape[:2]
+
+    detects = []
+    for tile_grid, loc_output in zip(tile_grids, loc_outputs):
+
+        tile_xtl = tile_grid['x']
+        tile_ytl = tile_grid['y']
+        tile_w = tile_grid['w']
+        tile_h = tile_grid['h']
+
+        for detect in loc_output:
+            detect_xtl = detect['x']
+            detect_ytl = detect['y']
+            detect_w = detect['w']
+            detect_h = detect['h']
+            detect_conf = detect['c']
+            detect_label = detect['l']
+
+            detect_xbr = detect_xtl + detect_w
+            detect_ybr = detect_ytl + detect_h
+
+            detect_box = {
+                'xtl': detect_xtl / tile_w,
+                'ytl': detect_ytl / tile_h,
+                'xbr': detect_xbr / tile_w,
+                'ybr': detect_ybr / tile_h,
+                'w': detect_w / tile_w,
+                'h': detect_h / tile_h,
+            }
+
+            margin_percent_w = margin / tile_w
+            margin_percent_h = margin / tile_h
+
+            center_box = {
+                'xtl': margin_percent_w,
+                'ytl': margin_percent_h,
+                'xbr': 1.0 - margin_percent_w,
+                'ybr': 1.0 - margin_percent_h,
+                'w': 1.0 - (2.0 * margin_percent_w),
+                'h': 1.0 - (2.0 * margin_percent_h),
+            }
+            area, _, inter, union = iou(detect_box, center_box)
+
+            overlap = 0.0 if area <= 0 else inter / area
+            overlap = round(overlap, 8)
+            assert 0.0 <= overlap and overlap <= 1.0
+            multiplier = np.sqrt(overlap)
+
+            final_conf = round(detect_conf * multiplier, 4)
+            if final_conf <= 0.0:
+                continue
+
+            final_xtl = int(np.around(tile_xtl + detect_xtl))
+            final_ytl = int(np.around(tile_ytl + detect_ytl))
+            final_w = int(np.around(detect_w))
+            final_h = int(np.around(detect_h))
+            final_xbr = final_xtl + final_w
+            final_ybr = final_ytl + final_h
+
+            # Check size with image frame
+            final_xtl = min(max(final_xtl, 0), img_w)
+            final_ytl = min(max(final_ytl, 0), img_h)
+            final_xbr = min(max(final_xbr, 0), img_w)
+            final_ybr = min(max(final_ybr, 0), img_h)
+            final_w = final_xbr - final_xtl
+            final_h = final_ybr - final_ytl
+
+            final_area = final_w * final_h
+            if final_area <= 0.0:
+                continue
+
+            detects.append(
+                {
+                    'l': detect_label,
+                    'c': final_conf,
+                    'x': final_xtl,
+                    'y': final_ytl,
+                    'w': final_w,
+                    'h': final_h,
+                }
+            )
+
+    return detects
+
+
+def compute(
+    img_shape, tile_grids, loc_outputs, agg_thresh=AGG_THRESH, nms_thresh=NMS_THRESH
+):
+    from scoutbot.agg.py_cpu_nms import py_cpu_nms
+
+    # Demosaic tile detection results and aggregate across the image
+    detects = demosaic(img_shape, tile_grids, loc_outputs)
+
+    # Filter low-confidence detections
+    detects = [detect for detect in detects if detect['c'] >= agg_thresh]
+
+    # Run NMS on aggregated detections
+    coords = np.vstack(
+        [
+            [
+                detect['x'],
+                detect['y'],
+                detect['x'] + detect['w'],
+                detect['y'] + detect['h'],
+            ]
+            for detect in detects
+        ]
+    )
+    confs = np.array([detect['c'] for detect in detects])
+
+    keeps = py_cpu_nms(coords, confs, nms_thresh)
+    final = ut.take(detects, keeps)
+    final.sort(key=lambda val: val['c'], reverse=True)
+
+    return final

scoutbot/agg/py_cpu_nms.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Ross Girshick
+# --------------------------------------------------------
+import numpy as np
+
+
+def py_cpu_nms(dets, scores, thresh):
+    """Pure Python NMS baseline."""
+    x1 = dets[:, 0]
+    y1 = dets[:, 1]
+    x2 = dets[:, 2]
+    y2 = dets[:, 3]
+
+    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    order = scores.argsort()[::-1]
+
+    keep = []
+    while order.size > 0:
+        i = order[0]
+        keep.append(i)
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+
+        w = np.maximum(0.0, xx2 - xx1 + 1)
+        h = np.maximum(0.0, yy2 - yy1 + 1)
+        inter = w * h
+        ovr = inter / (areas[i] + areas[order[1:]] - inter)
+
+        inds = np.where(ovr <= thresh)[0]
+        order = order[inds + 1]
+
+    keep = sorted(keep)
+    return keep

scoutbot/loc/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 '''
-2022 Wild Me
+The localizer (loc) is responsible for taking a (256, 256) tile image
 '''
 from os.path import exists, join
 from pathlib import Path
@@ -38,7 +38,7 @@ ANCHORS = [
     (11.2364, 10.0071),
 ]
 CLASS_LABEL_MAP = ['elephant_savanna']
-CONF_THRESH = 0.4
+LOC_THRESH = 0.4
 NMS_THRESH = 0.8
 
 ONNX_MODEL = 'scout.loc.5fbfff26.0.onnx'
@@ -46,8 +46,8 @@ ONNX_MODEL_PATH = join(PWD, 'models', 'onnx', ONNX_MODEL)
 ONNX_MODEL_HASH = '85a9378311d42b5143f74570136f32f50bf97c548135921b178b46ba7612b216'
 
 
-def fetch():
-    if exists(ONNX_MODEL_PATH):
+def fetch(pull=False):
+    if not pull and exists(ONNX_MODEL_PATH):
         onnx_model = ONNX_MODEL_PATH
     else:
         onnx_model = pooch.retrieve(
@@ -105,7 +105,7 @@ def predict(data, fill=True):
     return preds
 
 
-def post(preds, sizes, loc_thresh=CONF_THRESH, nms_thresh=NMS_THRESH):
+def post(preds, sizes, loc_thresh=LOC_THRESH, nms_thresh=NMS_THRESH):
     postprocess = Compose(
         [
             GetBoundingBoxes(NUM_CLASSES, ANCHORS, loc_thresh),
@@ -119,6 +119,18 @@ def post(preds, sizes, loc_thresh=CONF_THRESH, nms_thresh=NMS_THRESH):
     outputs = []
     for pred, size in zip(preds, sizes):
         output = ReverseLetterbox.apply([pred], INPUT_SIZE, size)
-        outputs.append(output[0])
+        output = output[0]
+        output = [
+            {
+                'l': detect.class_label,
+                'c': detect.confidence,
+                'x': detect.x_top_left,
+                'y': detect.y_top_left,
+                'w': detect.width,
+                'h': detect.height,
+            }
+            for detect in output
+        ]
+        outputs.append(output)
 
     return outputs

scoutbot/loc/convert.py

@@ -1,38 +1,6 @@
 # -*- coding: utf-8 -*-
 """
 pip install torch torchvision onnx onnxruntime-gpu tqdm wbia-utool scikit-learn numpy
-
-detection_config = {
-    'algo': 'tile_aggregation',
-    'config_filepath': 'variant3-32',
-    'weight_filepath': 'densenet+lightnet;scout-5fbfff26-boost3,0.400,scout_5fbfff26_v0,0.4',
-    'nms_thresh': 0.8,
-    'sensitivity': 0.5077,
-}
-
-(
-    wic_model_tag,
-    wic_thresh,
-    weight_filepath,
-    nms_thresh,
-) = 'scout-5fbfff26-boost3,0.400,scout_5fbfff26_v0,0.4'
-
-
-wic_confidence_list = ibs.scout_wic_test(
-    gid_list, classifier_algo='densenet', model_tag=wic_model_tag
-)
-config = {
-    'grid': False,
-    'algo': 'lightnet',
-    'config_filepath': weight_filepath,
-    'weight_filepath': weight_filepath,
-    'nms': True,
-    'nms_thresh': nms_thresh,
-    'sensitivity': 0.0,
-}
-prediction_list = depc.get_property(
-    'localizations', gid_list_, None, config=config
-)
 """
 import random
 import time

scoutbot/tile/__init__.py

@@ -19,18 +19,19 @@ def compute(img_filepath, grid1=True, grid2=True, ext=None, **kwargs):
     """Compute the tiles for a given input image"""
     assert exists(img_filepath)
     img = cv2.imread(img_filepath)
+    shape = img.shape
 
     grids = []
     if grid1:
-        grids += tile_grid(img.shape)
+        grids += tile_grid(shape)
     if grid2:
-        grids += tile_grid(img.shape, offset=TILE_WIDTH // 2, borders=False)
+        grids += tile_grid(shape, offset=TILE_WIDTH // 2, borders=False)
 
     filepaths = [tile_filepath(img_filepath, grid, ext=ext) for grid in grids]
     for grid, filepath in zip(grids, filepaths):
         assert tile_write(img, grid, filepath)
 
-    return filepaths
+    return shape, grids, filepaths
 
 
 def tile_write(img, grid, filepath):

scoutbot/wic/__init__.py

@@ -25,9 +25,11 @@ ONNX_MODEL_PATH = join(PWD, 'models', 'onnx', ONNX_MODEL)
 ONNX_MODEL_HASH = 'cbc7f381fa58504e03b6510245b6b2742d63049429337465d95663a6468df4c1'
 ONNX_CLASSES = ['negative', 'positive']
 
+WIC_THRESH = 0.2
 
-def fetch():
-    if exists(ONNX_MODEL_PATH):
+
+def fetch(pull=False):
+    if not pull and exists(ONNX_MODEL_PATH):
         onnx_model = ONNX_MODEL_PATH
     else:
         onnx_model = pooch.retrieve(

tests/test_agg.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+from os.path import abspath, join
+
+import utool as ut
+
+from scoutbot import agg, loc, tile, wic
+
+
+def test_agg_compute():
+    img_filepath = abspath(join('examples', '1be4d40a-6fd0-42ce-da6c-294e45781f41.jpg'))
+
+    # Run tiling
+    img_shape, tile_grids, tile_filepaths = tile.compute(img_filepath)
+    assert len(tile_filepaths) == 1252
+
+    # Run WIC
+    wic_outputs = wic.post(wic.predict(wic.pre(tile_filepaths)))
+    assert len(wic_outputs) == len(tile_filepaths)
+
+    # Threshold for WIC
+    flags = [wic_output.get('positive') >= wic.WIC_THRESH for wic_output in wic_outputs]
+    loc_tile_grids = ut.compress(tile_grids, flags)
+    loc_tile_filepaths = ut.compress(tile_filepaths, flags)
+    assert sum(flags) == 15
+
+    # Run localizer
+    loc_data, loc_sizes = loc.pre(loc_tile_filepaths)
+    loc_preds = loc.predict(loc_data)
+    loc_outputs = loc.post(
+        loc_preds, loc_sizes, loc_thresh=loc.LOC_THRESH, nms_thresh=loc.NMS_THRESH
+    )
+    assert len(loc_tile_grids) == len(loc_outputs)
+
+    # Aggregate
+    detects = agg.compute(
+        img_shape,
+        loc_tile_grids,
+        loc_outputs,
+        agg_thresh=agg.AGG_THRESH,
+        nms_thresh=agg.NMS_THRESH,
+    )
+
+    assert len(detects) == 3
+
+    targets = [
+        {'l': 'elephant_savanna', 'c': 0.9299, 'x': 4597, 'y': 2322, 'w': 72, 'h': 149},
+        {'l': 'elephant_savanna', 'c': 0.8739, 'x': 4865, 'y': 2422, 'w': 97, 'h': 109},
+        {'l': 'elephant_savanna', 'c': 0.7115, 'x': 4806, 'y': 2476, 'w': 66, 'h': 119},
+    ]
+
+    for output, target in zip(detects, targets):
+        for key in target.keys():
+            if key == 'l':
+                assert output.get(key) == target.get(key)
+            elif key == 'c':
+                assert abs(output.get(key) - target.get(key)) < 1e-2
+            else:
+                assert abs(output.get(key) - target.get(key)) < 3

tests/test_loc.py

@@ -47,53 +47,53 @@ def test_loc_onnx_pipeline():
     # fmt: off
     targets = [
         {
-            'class_label': 'elephant_savanna',
-            'x_top_left': 206.00893930,
-            'y_top_left': 189.09138371,
-            'width'     :  53.78145658,
-            'height'    :  66.46106896,
-            'confidence':   0.77065581,
+            'l': 'elephant_savanna',
+            'x': 206.00893930,
+            'y': 189.09138371,
+            'w':  53.78145658,
+            'h':  66.46106896,
+            'c':   0.77065581,
         },
         {
-            'class_label': 'elephant_savanna',
-            'x_top_left': 216.61065204,
-            'y_top_left': 193.30525090,
-            'width'     :  42.83404541,
-            'height'    :  62.44728440,
-            'confidence':   0.61152166,
+            'l': 'elephant_savanna',
+            'x': 216.61065204,
+            'y': 193.30525090,
+            'w':  42.83404541,
+            'h':  62.44728440,
+            'c':   0.61152166,
         },
         {
-            'class_label': 'elephant_savanna',
-            'x_top_left':  51.61210749,
-            'y_top_left': 235.37819260,
-            'width'     :  79.69709660,
-            'height'    :  17.41258826,
-            'confidence':   0.50862342,
+            'l': 'elephant_savanna',
+            'x':  51.61210749,
+            'y': 235.37819260,
+            'w':  79.69709660,
+            'h':  17.41258826,
+            'c':   0.50862342,
         },
         {
-            'class_label': 'elephant_savanna',
-            'x_top_left':  57.47630427,
-            'y_top_left': 236.92587515,
-            'width'     :  94.69935960,
-            'height'    :  16.03246718,
-            'confidence':   0.44841822,
+            'l': 'elephant_savanna',
+            'x':  57.47630427,
+            'y': 236.92587515,
+            'w':  94.69935960,
+            'h':  16.03246718,
+            'c':   0.44841822,
         },
         {
-            'class_label': 'elephant_savanna',
-            'x_top_left':  37.07233605,
-            'y_top_left': 230.39122596,
-            'width'     : 105.40560208,
-            'height'    :  24.81017362,
-            'confidence':   0.44012001,
+            'l': 'elephant_savanna',
+            'x':  37.07233605,
+            'y': 230.39122596,
+            'w': 105.40560208,
+            'h':  24.81017362,
+            'c':   0.44012001,
         },
     ]
     # fmt: on
 
     for output, target in zip(outputs[0], targets):
         for key in target.keys():
-            if key == 'class_label':
-                assert getattr(output, key) == target.get(key)
-            elif key == 'confidence':
-                assert abs(getattr(output, key) - target.get(key)) < 1e-2
+            if key == 'l':
+                assert output.get(key) == target.get(key)
+            elif key == 'c':
+                assert abs(output.get(key) - target.get(key)) < 1e-2
             else:
-                assert abs(getattr(output, key) - target.get(key)) < 3
+                assert abs(output.get(key) - target.get(key)) < 3

tests/test_scoutbot.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from os.path import abspath, join
+
+import scoutbot
+
+
+def test_fetch():
+    scoutbot.fetch(pull=False)
+    scoutbot.fetch(pull=True)
+
+
+def test_pipeline():
+    img_filepath = abspath(join('examples', '1be4d40a-6fd0-42ce-da6c-294e45781f41.jpg'))
+
+    detects = scoutbot.pipeline(img_filepath)
+    assert len(detects) == 3
+
+    targets = [
+        {'l': 'elephant_savanna', 'c': 0.9299, 'x': 4597, 'y': 2322, 'w': 72, 'h': 149},
+        {'l': 'elephant_savanna', 'c': 0.8739, 'x': 4865, 'y': 2422, 'w': 97, 'h': 109},
+        {'l': 'elephant_savanna', 'c': 0.7115, 'x': 4806, 'y': 2476, 'w': 66, 'h': 119},
+    ]
+
+    for output, target in zip(detects, targets):
+        for key in target.keys():
+            if key == 'l':
+                assert output.get(key) == target.get(key)
+            elif key == 'c':
+                assert abs(output.get(key) - target.get(key)) < 1e-2
+            else:
+                assert abs(output.get(key) - target.get(key)) < 3

tests/test_tile.py

@@ -81,7 +81,7 @@ def test_tile_compute():
     from scoutbot.tile import compute
 
     img_filepath = abspath(join('examples', '1be4d40a-6fd0-42ce-da6c-294e45781f41.jpg'))
-    filepaths = compute(img_filepath)
+    shape, grids, filepaths = compute(img_filepath)
 
     assert len(filepaths) == 1252
     for filepath in filepaths: