Fix rounding error when resizing, add example for classifying standalone image

Author: janjongboom

.gitignore

@@ -2,3 +2,4 @@ __pycache__
 dist
 edge_impulse_linux.egg-info
 build
+*.jpg

README.md

@@ -56,6 +56,7 @@ Then you can start classifying realtime sensor data. We have examples for:
 
 * [Audio](https://github.com/edgeimpulse/linux-sdk-python/blob/master/examples/audio/classify.py) - grabs data from the microphone and classifies it in realtime.
 * [Camera](https://github.com/edgeimpulse/linux-sdk-python/blob/master/examples/image/classify.py) - grabs data from a webcam and classifies it in realtime.
+* [Still image](https://github.com/edgeimpulse/linux-sdk-python/blob/master/examples/image/classify-image.py) - classifies a still image from your hard drive.
 * [Custom data](https://github.com/edgeimpulse/linux-sdk-python/blob/master/examples/custom/classify.py) - classifies custom sensor data.
 
 ## Troubleshooting

edge_impulse_linux/image.py

@@ -3,7 +3,7 @@
 import numpy as np
 import cv2
 from edge_impulse_linux.runner import ImpulseRunner
-import time
+import math
 import psutil
 
 class ImageImpulseRunner(ImpulseRunner):
@@ -17,7 +17,7 @@ def __init__(self, model_path: str):
 
     def init(self):
         if psutil.OSX or psutil.MACOS:
-            print('Make sure that video devices access is granted for your application. runnin')
+            print('Make sure that video devices access is granted for your application.')
             print('If your video device is not responding, try running "tccutil reset Camera" to reset the camera access privileges')
 
         model_info = super(ImageImpulseRunner, self).init()
@@ -49,46 +49,51 @@ def classifier(self, videoDeviceId = 0):
         while not self.closed:
             success, img = self.videoCapture.read()
             if success:
-                features = []
+                features, cropped = self.get_features_from_image(img)
 
-                EI_CLASSIFIER_INPUT_WIDTH = self.dim[0]
-                EI_CLASSIFIER_INPUT_HEIGHT = self.dim[1]
+                res = self.classify(features)
+                yield res, cropped
 
-                in_frame_cols = img.shape[1]
-                in_frame_rows = img.shape[0]
+    def get_features_from_image(self, img):
+        features = []
 
-                factor_w = EI_CLASSIFIER_INPUT_WIDTH / in_frame_cols
-                factor_h = EI_CLASSIFIER_INPUT_HEIGHT / in_frame_rows
+        EI_CLASSIFIER_INPUT_WIDTH = self.dim[0]
+        EI_CLASSIFIER_INPUT_HEIGHT = self.dim[1]
 
-                largest_factor = factor_w if factor_w > factor_h else factor_h
+        in_frame_cols = img.shape[1]
+        in_frame_rows = img.shape[0]
 
-                resize_size_w = int(largest_factor * in_frame_cols)
-                resize_size_h = int(largest_factor * in_frame_rows)
-                resize_size = (resize_size_w, resize_size_h)
+        factor_w = EI_CLASSIFIER_INPUT_WIDTH / in_frame_cols
+        factor_h = EI_CLASSIFIER_INPUT_HEIGHT / in_frame_rows
 
-                resized = cv2.resize(img, resize_size, interpolation = cv2.INTER_AREA)
+        largest_factor = factor_w if factor_w > factor_h else factor_h
 
-                crop_x = int((resize_size_w - resize_size_h) / 2) if resize_size_w > resize_size_h else 0
-                crop_y = int((resize_size_h - resize_size_w) / 2) if resize_size_h > resize_size_w else 0
+        resize_size_w = int(math.ceil(largest_factor * in_frame_cols))
+        resize_size_h = int(math.ceil(largest_factor * in_frame_rows))
+        resize_size = (resize_size_w, resize_size_h)
 
-                crop_region = (crop_x, crop_y, EI_CLASSIFIER_INPUT_WIDTH, EI_CLASSIFIER_INPUT_HEIGHT)
+        resized = cv2.resize(img, resize_size, interpolation = cv2.INTER_AREA)
 
-                cropped = resized[crop_region[1]:crop_region[1]+crop_region[3], crop_region[0]:crop_region[0]+crop_region[2]]
+        crop_x = int((resize_size_w - resize_size_h) / 2) if resize_size_w > resize_size_h else 0
+        crop_y = int((resize_size_h - resize_size_w) / 2) if resize_size_h > resize_size_w else 0
 
-                if self.isGrayscale:
-                    cropped = cv2.cvtColor(cropped, cv2.COLOR_BGR2GRAY)
-                    pixels = np.array(cropped).flatten().tolist()
+        crop_region = (crop_x, crop_y, EI_CLASSIFIER_INPUT_WIDTH, EI_CLASSIFIER_INPUT_HEIGHT)
 
-                    for p in pixels:
-                        features.append((p << 16) + (p << 8) + p)
-                else:
-                    pixels = np.array(cropped).flatten().tolist()
+        cropped = resized[crop_region[1]:crop_region[1]+crop_region[3], crop_region[0]:crop_region[0]+crop_region[2]]
 
-                    for ix in range(0, len(pixels), 3):
-                        b = pixels[ix + 0]
-                        g = pixels[ix + 1]
-                        r = pixels[ix + 2]
-                        features.append((r << 16) + (g << 8) + b)
+        if self.isGrayscale:
+            cropped = cv2.cvtColor(cropped, cv2.COLOR_BGR2GRAY)
+            pixels = np.array(cropped).flatten().tolist()
 
-                res = self.classify(features)
-                yield res, cropped
+            for p in pixels:
+                features.append((p << 16) + (p << 8) + p)
+        else:
+            pixels = np.array(cropped).flatten().tolist()
+
+            for ix in range(0, len(pixels), 3):
+                b = pixels[ix + 0]
+                g = pixels[ix + 1]
+                r = pixels[ix + 2]
+                features.append((r << 16) + (g << 8) + b)
+
+        return features, cropped

examples/image/classify-image.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+
+import cv2
+import os
+import sys, getopt
+import numpy as np
+from edge_impulse_linux.image import ImageImpulseRunner
+
+runner = None
+
+def help():
+    print('python classify-image.py <path_to_model.eim> <path_to_image.jpg>')
+
+def main(argv):
+    try:
+        opts, args = getopt.getopt(argv, "h", ["--help"])
+    except getopt.GetoptError:
+        help()
+        sys.exit(2)
+
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            help()
+            sys.exit()
+
+    if len(args) != 2:
+        help()
+        sys.exit(2)
+
+    model = args[0]
+
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    modelfile = os.path.join(dir_path, model)
+
+    print('MODEL: ' + modelfile)
+
+    with ImageImpulseRunner(modelfile) as runner:
+        try:
+            model_info = runner.init()
+            print('Loaded runner for "' + model_info['project']['owner'] + ' / ' + model_info['project']['name'] + '"')
+            labels = model_info['model_parameters']['labels']
+
+            img = cv2.imread(args[1])
+
+            features, cropped = runner.get_features_from_image(img)
+
+            # the image will be resized and cropped, save a copy of the picture here
+            # so you can see what's being passed into the classifier
+            cv2.imwrite('debug.jpg', cropped)
+
+            res = runner.classify(features)
+
+            if "classification" in res["result"].keys():
+                print('Result (%d ms.) ' % (res['timing']['dsp'] + res['timing']['classification']), end='')
+                for label in labels:
+                    score = res['result']['classification'][label]
+                    print('%s: %.2f\t' % (label, score), end='')
+                print('', flush=True)
+
+            elif "bounding_boxes" in res["result"].keys():
+                print('Found %d bounding boxes (%d ms.)' % (len(res["result"]["bounding_boxes"]), res['timing']['dsp'] + res['timing']['classification']))
+                for bb in res["result"]["bounding_boxes"]:
+                    print('\t%s (%.2f): x=%d y=%d w=%d h=%d' % (bb['label'], bb['value'], bb['x'], bb['y'], bb['width'], bb['height']))
+        finally:
+            if (runner):
+                runner.stop()
+
+if __name__ == "__main__":
+   main(sys.argv[1:])

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = edge_impulse_linux
-version = 1.0.2
+version = 1.0.3
 author = EdgeImpulse Inc.
 author_email = hello@edgeimpulse.com
 description = Python runner for real-time ML classification