def test_image_classification_mobilenet(self): avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.MOBILENET), partial(image_classification.get_classes, threshold=CLASSIFICATION_THRESHOLD)) self.assertLatency(avg_bonnet, 42.0) self.assertLatency(avg_end_to_end, 80.0, 0.3)
def main(): parser = argparse.ArgumentParser( 'Image classification camera inference example.') parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, dest='num_objects', default=3, help='Sets the number of object interences to print.') args = parser.parse_args() # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes with PiCamera(sensor_mode=4, framerate=30) as camera: camera.start_preview() with CameraInference(image_classification.model()) as inference: for result in inference.run(args.num_frames): classes = image_classification.get_classes(result) print(classes_info(classes, args.num_objects)) camera.stop_preview()
def main(): parser = argparse.ArgumentParser( 'Image classification camera inference example.') parser.add_argument( '--num_frames', '-n', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, default=3, help='Sets the number of object interences to print.') parser.add_argument('--nopreview', dest='preview', action='store_false', default=True, help='Enable camera preview') args = parser.parse_args() with PiCamera(sensor_mode=4, framerate=30) as camera, \ CameraPreview(camera, enabled=args.preview), \ CameraInference(image_classification.model()) as inference: for result in inference.run(args.num_frames): classes = image_classification.get_classes(result, top_k=args.num_objects) print(classes_info(classes)) if classes: camera.annotate_text = '%s (%.2f)' % classes[0]
def test_image_classification_squeezenet(self): avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.SQUEEZENET), partial(image_classification.get_classes, threshold=CLASSIFICATION_THRESHOLD)) self.assertLatency(avg_bonnet, 183.0) self.assertLatency(avg_end_to_end, 202.0)
def run(self): while self._running: try: self.logger.debug('loading inference model ...') with CameraInference( image_classification.model()) as inference: self.logger.debug('running inference ...') for result in inference.run(): predictions = image_classification.get_classes( result, top_k=self.top_k_predictions(), threshold=0) outgoing_signals = [] for label, score in predictions: signal_dict = { 'label': label, 'score': score, } outgoing_signal = Signal(signal_dict) outgoing_signals.append(outgoing_signal) if not self._running: break self.notify_signals(outgoing_signals) except: self.logger.exception('failed to get inference result!') self.reset_camera() self.release_camera()
def model_selector(argument): options = { "object": object_detection.model(), "face": face_detection.model(), "class": image_classification.model() } return options.get(argument, "nothing")
def main(): importJsonData() ser.write(("START").encode()) ser.write(str.encode('\n')) parser = argparse.ArgumentParser( 'Image classification camera inference example.') parser.add_argument( '--num_frames', '-n', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, default=3, help='Sets the number of object interences to print.') parser.add_argument('--nopreview', dest='preview', action='store_false', default=True, help='Enable camera preview') args = parser.parse_args() with PiCamera(sensor_mode=4, framerate=10) as camera, \ CameraPreview(camera, enabled=args.preview), \ CameraInference(image_classification.model()) as inference: camera.vflip = True for result in inference.run(args.num_frames): classes = image_classification.get_classes(result, top_k=args.num_objects) className = classes[0][0].split('/')[ 0] #this is because I only want one category at the time print(className) index = getClassIndex(className) print(index) smorfia_number = getSmorfiaNumber(index) print(smorfia_number) smorfia_label = getSmorfiaLabel(smorfia_number) print(smorfia_label) ser.write((str(smorfia_number)).encode()) ser.write(str.encode(':')) ser.write(smorfia_label.encode()) ser.write(str.encode('\n')) print('\n') time.sleep( 1) # Delays for 5 seconds. You can also use a float value. if classes: camera.annotate_text = '%s (%.2f)' % classes[0]
def main(): parser = argparse.ArgumentParser( description='Example application for displaying a dial indicator for ' 'what object is seen') parser.add_argument( '--output_overlay', default=True, type=bool, help='Should the visual overlay be generated') parser.add_argument( '--button_enabled', default=True, type=bool, help='Should the button be monitored') parser.add_argument( '--button_active', default=False, type=bool, help='Should the button start out active (true) or only be active once ' 'pressed (false)') flags = parser.parse_args() load_model = time.time() category_count = len(category_mapper.get_categories()) button = AutoButton(flags.button_active, flags.button_enabled) for category in category_mapper.get_categories(): print('Category[%d]: %s' % (category_mapper.get_category_index(category), category)) with picamera.PiCamera() as camera: camera.resolution = (1640, 1232) camera.start_preview() overlay = OverlayManager( camera) if flags.output_overlay else DummyOverlayManager() servo = AngularServo(PIN_A, min_pulse_width=.0005, max_pulse_width=.0019) with CameraInference(image_classification.model()) as classifier: print('Load Model %f' % (time.time() - load_model)) for result in classifier.run(): if not button.on(): overlay.clear() servo.angle = -90 continue classes = image_classification.get_classes(result) probs = [0] * (category_count + 1) result_categories = [] for label, score in classes: category = category_mapper.get_category(label) or 'Other' probs[category_mapper.get_category_index(category) + 1] += score result_categories.append(category) overlay.update(classes, result_categories) max_prob = max(probs) best_category = probs.index(max_prob) if best_category == 0 and max_prob > .5: servo.angle = -90 elif best_category != 0: servo.angle = -90 + (180 * best_category) / category_count print('category: %d - %s' % (best_category, category_mapper.get_categories()[best_category - 1]))
def main(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--input', '-i', required=True, help='Input image file.') parser.add_argument('--threshold', '-t', type=float, default=0.1, help='Classification probability threshold.') parser.add_argument('--top_k', '-n', type=int, default=5, help='Max number of returned classes.') parser.add_argument('--sparse', '-s', action='store_true', default=False, help='Use sparse tensors.') parser.add_argument('--model', '-m', choices=('squeezenet', 'mobilenet'), default='mobilenet', help='Model to run.') args = parser.parse_args() # There are two models available for image classification task: # 1) MobileNet based (image_classification.MOBILENET), which has 59.9% top-1 # accuracy on ImageNet; # 2) SqueezeNet based (image_classification.SQUEEZENET), which has 45.3% top-1 # accuracy on ImageNet; model_type = { 'squeezenet': image_classification.SQUEEZENET, 'mobilenet': image_classification.MOBILENET }[args.model] with ImageInference(image_classification.model(model_type)) as inference: image = Image.open(args.input) if args.sparse: configs = image_classification.sparse_configs( top_k=args.top_k, threshold=args.threshold, model_type=model_type) result = inference.run(image, sparse_configs=configs) classes = image_classification.get_classes_sparse(result) else: result = inference.run(image) classes = image_classification.get_classes( result, top_k=args.top_k, threshold=args.threshold) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--input', '-i', dest='input', required=True) args = parser.parse_args() with ImageInference(image_classification.model()) as inference: image = Image.open(args.input) classes = image_classification.get_classes(inference.run(image)) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))
def test_image_classification_squeezenet_sparse(self): sparse_configs = image_classification.sparse_configs( threshold=CLASSIFICATION_THRESHOLD, model_type=image_classification.SQUEEZENET) avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.SQUEEZENET), partial(image_classification.get_classes_sparse), sparse_configs=sparse_configs) self.assertLatency(avg_bonnet, 183.0) self.assertLatency(avg_end_to_end, 202.0)
def test_image_classification_mobilenet_sparse(self): sparse_configs = image_classification.sparse_configs( threshold=CLASSIFICATION_THRESHOLD, model_type=image_classification.MOBILENET) avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.MOBILENET), image_classification.get_classes_sparse, sparse_configs=sparse_configs) self.assertLatency(avg_bonnet, 42.0) self.assertLatency(avg_end_to_end, 56.0)
def process(self, file): model_type = image_classification.MOBILENET with ImageInference( image_classification.model(model_type)) as inference: image = file classes = image_classification.get_classes( inference.run(image), max_num_objects=5, object_prob_threshold=0.1) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))
def main(): """Image classification camera inference example.""" parser = argparse.ArgumentParser() parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=-1, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, dest='num_objects', default=3, help='Sets the number of object interences to print.') args = parser.parse_args() def print_classes(classes, object_count): s = '' for index, (obj, prob) in enumerate(classes): if index > object_count - 1: break s += '%s=%1.2f\t|\t' % (obj, prob) print('%s\r' % s) with PiCamera() as camera: # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = (1640, 1232) # Start the camera stream. camera.framerate = 30 camera.start_preview() with CameraInference(image_classification.model()) as inference: for i, result in enumerate(inference.run()): if i == args.num_frames: break classes = image_classification.get_classes(result) print_classes(classes, args.num_objects) i = i + 1 camera.stop_preview()
def main(): global count global lasttime global testing num_frames = None num_objects = 8 # just for debug printing # Forced sensor mode, 1640x1232, full FoV. use mode 4, was using frame rate of 10 # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # kevinh 3280x2464 is mode 3 (but that is too large for twitter) with PiCamera(sensor_mode=4, framerate=3) as camera: camera.awb_mode = 'sunlight' camera.exposure_mode = 'sports' # if out of memory err occurs see https://stackoverflow.com/questions/39251815/python-not-taking-picture-at-highest-resolution-from-raspberry-pi-camera camera.resolution = (1920, 1080) with CameraInference( image_classification.model( image_classification.MOBILENET)) as inference: for result in inference.run(num_frames): classes = image_classification.get_classes(result) newclasses = list(filter(removeold, classes)) if newclasses: print(classes_info(newclasses, num_objects)) name = newclasses[0][0] filename = name.replace("/", "_").replace(" ", ".") hasbird = list( filter(lambda canidate: (canidate in name), interesting)) filename += ".jpg" # print('writing', filename) if hasbird: camera.capture( filename ) # the twitter client only reads from disk (for now FIXME) now = datetime.datetime.now() deltat = now - lasttime if deltat > maxdelta: lasttime = now if not testing: tweeter.tweet( filename, 'I just saw a hummingbird! tweet tweet!') print('tweet a bird') else: print('test a bird') else: print('ignore a bird')
def testDogMobilenet(self): with TestImage('dog.jpg') as image: with ImageInference( image_classification.model( image_classification.MOBILENET)) as inference: classes = image_classification.get_classes( inference.run(image)) label, score = classes[0] self.assertEqual('boxer', label) self.assertAlmostEqual(score, 0.684, delta=0.001) label, score = classes[1] self.assertEqual('bull mastiff', label) self.assertAlmostEqual(score, 0.222, delta=0.001)
def test_classification(self): with TestImage(self.image_file) as image: with ImageInference(ic.model(self.model_type)) as inference: if self.sparse: sparse_configs = ic.sparse_configs(top_k=self.TOP_K, threshold=self.THRESHOLD, model_type=self.model_type) result = inference.run(image, sparse_configs=sparse_configs) classes = ic.get_classes_sparse(result) else: result = inference.run(image) classes = ic.get_classes(result, top_k=self.TOP_K, threshold=self.THRESHOLD) self.check(classes)
def testDogSqueezenet(self): with TestImage('dog.jpg') as image: with ImageInference( image_classification.model( image_classification.SQUEEZENET)) as inference: classes = image_classification.get_classes( inference.run(image)) label, score = classes[0] self.assertEqual('pug/pug-dog', label) self.assertAlmostEqual(score, 0.271, delta=0.001) label, score = classes[1] self.assertEqual('bull mastiff', label) self.assertAlmostEqual(score, 0.141, delta=0.001)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--input', '-i', dest='input', required=True) parser.add_argument('--output', '-o', dest='output') args = parser.parse_args() with ImageInference(image_classification.model()) as inference: image = Image.open(args.input) image_center, offset = _crop_center(image) draw = ImageDraw.Draw(image) result = inference.run(image_center) for i, obj in enumerate(image_classification.get_objects(result, 0.3, offset)): print('Object #%d: %s' % (i, str(obj))) x, y, width, height = obj.bounding_box draw.rectangle((x, y, x + width, y + height), outline='red') if args.output: image.save(args.output)
def main(): parser = argparse.ArgumentParser('Image classification camera inference example.') parser.add_argument('--num_frames', '-n', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, default=3, help='Sets the number of object interences to print.') parser.add_argument('--nopreview', dest='preview', action='store_false', default=True, help='Enable camera preview') args = parser.parse_args() with PiCamera(sensor_mode=4, framerate=30) as camera, \ CameraPreview(camera, enabled=args.preview), \ CameraInference(image_classification.model()) as inference: for result in inference.run(args.num_frames): classes = image_classification.get_classes(result, top_k=args.num_objects) print(classes_info(classes)) if classes: camera.annotate_text = '%s (%.2f)' % classes[0]
def main(): parser = argparse.ArgumentParser() parser.add_argument('--input', '-i', dest='input', required=True) args = parser.parse_args() # There are two models available for image classification task: # 1) MobileNet based (image_classification.MOBILENET), which has 59.9% top-1 # accuracy on ImageNet; # 2) SqueezeNet based (image_classification.SQUEEZENET), which has 45.3% top-1 # accuracy on ImageNet; model_type = image_classification.MOBILENET with ImageInference(image_classification.model(model_type)) as inference: image = Image.open( io.BytesIO(sys.stdin.buffer.read()) if args.input == '-' else args.input) classes = image_classification.get_classes(inference.run(image), max_num_objects=5, object_prob_threshold=0.1) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))
def main(): parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--input', '-i', required=True, help='Input image file.') parser.add_argument('--threshold', '-t', type=float, default=0.1, help='Classification probability threshold.') parser.add_argument('--top_k', '-n', type=int, default=5, help='Max number of returned classes.') parser.add_argument('--sparse', '-s', action='store_true', default=False, help='Use sparse tensors.') parser.add_argument('--model', '-m', choices=('squeezenet', 'mobilenet'), default='mobilenet', help='Model to run.') args = parser.parse_args() # There are two models available for image classification task: # 1) MobileNet based (image_classification.MOBILENET), which has 59.9% top-1 # accuracy on ImageNet; # 2) SqueezeNet based (image_classification.SQUEEZENET), which has 45.3% top-1 # accuracy on ImageNet; model_type = {'squeezenet': image_classification.SQUEEZENET, 'mobilenet': image_classification.MOBILENET}[args.model] with ImageInference(image_classification.model(model_type)) as inference: image = Image.open(args.input) if args.sparse: configs = image_classification.sparse_configs(top_k=args.top_k, threshold=args.threshold, model_type=model_type) result = inference.run(image, sparse_configs=configs) classes = image_classification.get_classes_sparse(result) else: result = inference.run(image) classes = image_classification.get_classes(result, top_k=args.top_k, threshold=args.threshold) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))
def main(): parser = argparse.ArgumentParser( 'Image classification camera inference example.') parser.add_argument( '--num_frames', '-n', type=int, default=None, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, default=2, help='Sets the number of object interences to print.') parser.add_argument('--nopreview', dest='preview', action='store_false', default=True, help='Enable camera preview') args = parser.parse_args() with PiCamera(sensor_mode=4, framerate=30) as camera, \ CameraPreview(camera, enabled=args.preview), \ CameraInference(image_classification.model()) as inference, \ Leds() as leds: leds.update(Leds.privacy_on()) for result in inference.run(args.num_frames): classes = image_classification.get_classes(result, top_k=args.num_objects, threshold=.3) print(classes_info(classes)) if classes: #annotator.clear() camera.annotate_text = '%s (%.2f)' % classes[0] if 'chicken' in classes[0]: camera.capture('chickens.jpg') print('Chicken captured')
def main(): """Image classification camera inference example.""" parser = argparse.ArgumentParser() button = Button(23) parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=-1, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument( '--num_objects', '-c', type=int, dest='num_objects', default=1, help='Sets the number of object interences to print.') args = parser.parse_args() def print_classes(classes, object_count): s = '' for index, (obj, prob) in enumerate(classes): if index > object_count - 1: break s += '%s=%1.2f\t|\t' % (obj, prob) f = open('object_recognition.txt','w') f.write(s) f.close() print('%s\r' % s) sys.stdout.flush() def firebase_upload(fileName): camera.capture('/home/pi/NotPushedToWifi/%s.jpg' % fileName) # print('Image captured') # print('%s' % fileName) with PiCamera() as camera: print('Script Started') # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = (1640, 1232) # Start the camera stream. camera.framerate = 30 #camera.start_preview() model_type = image_classification.MOBILENET counter = 0 with CameraInference(image_classification.model(model_type)) as inference: for i, result in enumerate(inference.run()): if i == args.num_frames: break classes = image_classification.get_classes(result) if button.is_pressed: now = datetime.now() local_time = now.strftime("%I-%M-%S_%Y-%d-%B") firebase_upload(local_time) print_classes(classes, args.num_objects) time.sleep(.5)
def testImageClassificationMobilenetLatency(self): avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.MOBILENET), image_classification.get_classes) self.assertLatency(avg_bonnet, 42.0) self.assertLatency(avg_end_to_end, 80.0, 0.3)
def testImageClassificationSqueezenetLatency(self): avg_end_to_end, avg_bonnet = self.benchmarkModel( image_classification.model(image_classification.SQUEEZENET), image_classification.get_classes) self.assertLatency(avg_bonnet, 183.0) self.assertLatency(avg_end_to_end, 202.0)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--classfile', '-c', dest='classfile', required=True) parser.add_argument( '--threshold', '-t', dest='threshold', required=False, type=float, default=0.5) parser.add_argument('--out_dir', '-o', dest='out_dir', required=False, type=str, default='./') parser.add_argument( '--capture_delay', dest='capture_delay', required=False, type=float, default=5.0) parser.add_argument( '--capture_length', dest='capture_length', required=False, type=int, default=20) parser.add_argument('--debug', '-d', dest='debug', required=False, action='store_true') # Crop box in fraction of the image width. By default full camera image is processed. parser.add_argument( '--cropbox_left', dest='cropbox_left', required=False, type=float, default=0.0) parser.add_argument( '--cropbox_right', dest='cropbox_right', required=False, type=float, default=1.0) parser.add_argument( '--cropbox_top', dest='cropbox_top', required=False, type=float, default=0.0) parser.add_argument( '--cropbox_bottom', dest='cropbox_bottom', required=False, type=float, default=1.0) parser.set_defaults(debug=False) args = parser.parse_args() # There are two models available for image classification task: # 1) MobileNet based (image_classification.MOBILENET), which has 59.9% top-1 # accuracy on ImageNet; # 2) SqueezeNet based (image_classification.SQUEEZENET), which has 45.3% top-1 # accuracy on ImageNet; model_type = image_classification.MOBILENET # Read the class list from a text file with open(args.classfile) as f: classes = [line.strip() for line in f] print('Starting camera detection, using the following classes:') for label in classes: print(' ', label) print('Threshold:', args.threshold) print('Debug mode:', args.debug) print('Capture Delay:', args.capture_delay) debug_out = args.out_dir if args.debug else '' with ImageInference(image_classification.model(model_type)) as inference: with picamera.PiCamera(resolution=(1920, 1080)) as camera: stream = picamera.PiCameraCircularIO(camera, seconds=args.capture_length) camera.start_recording(stream, format='h264') while True: detection, image, inference_data = detect_object( inference, camera, classes, args.threshold, debug_out, (args.cropbox_left, args.cropbox_right), (args.cropbox_top, args.cropbox_bottom)) if detection: detect_time = int(time.time()) camera.wait_recording(args.capture_delay) video_file = 'capture_%d.mpeg' % detect_time image_file = 'capture_%d.jpg' % detect_time stream.copy_to(os.path.join(args.out_dir, video_file)) stream.flush() debug_output(image, inference_data, args.out_dir, image_file) print('Wrote video file to', os.path.join(args.out_dir, video_file)) camera.wait_recording(max(args.capture_length - args.capture_delay, 0))
def main(): """Image classification camera inference example.""" parser = argparse.ArgumentParser() #button = Button(23) pin = 24 parser.add_argument( '--num_frames', '-n', type=int, dest='num_frames', default=-1, help='Sets the number of frames to run for, otherwise runs forever.') parser.add_argument('--num_objects', '-c', type=int, dest='num_objects', default=1, help='Sets the number of object interences to print.') args = parser.parse_args() def print_classes(classes, object_count): s = '' for index, (obj, prob) in enumerate(classes): if index > object_count - 1: break s += '%s=%1.2f\t|\t' % (obj, prob) f = open('./object_recognition.txt', 'w') f.write(s) f.close() print('%s\r' % s) def firebase_upload(counter): camera.capture('/home/pi/training_images/firebase_image%s.jpg' % counter) print('Image captured: firebase_image%s.jpg' % counter) with PiCamera() as camera: print('Script Started') # Forced sensor mode, 1640x1232, full FoV. See: # https://picamera.readthedocs.io/en/release-1.13/fov.html#sensor-modes # This is the resolution inference run on. camera.sensor_mode = 4 # Scaled and cropped resolution. If different from sensor mode implied # resolution, inference results must be adjusted accordingly. This is # true in particular when camera.start_recording is used to record an # encoded h264 video stream as the Pi encoder can't encode all native # sensor resolutions, or a standard one like 1080p may be desired. camera.resolution = (1640, 1232) # Start the camera stream. camera.framerate = 30 # camera.start_preview() GPIO.setmode(GPIO.BCM) GPIO.setup(pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) state = GPIO.input(pin) counter = 0 model_type = image_classification.MOBILENET with CameraInference( image_classification.model(model_type)) as inference: for i, result in enumerate(inference.run()): state = GPIO.input(pin) if i == args.num_frames: break classes = image_classification.get_classes(result) #if button.is_pressed or if state == 1: counter += 1 print_classes(classes, args.num_objects) #firebase_upload(counter) time.sleep(.5)
#!/usr/bin/env python # This file is a modified version of image_classification.py from Google AIY Vision Kit. import argparse from PIL import Image import subprocess from aiy.vision.inference import ImageInference from aiy.vision.models import image_classification devnull = open('os.devnull', 'w') ipaddr = subprocess.check_output(["hostname", "-I"]).decode("utf-8").strip() commd = "http://" + ipaddr + ":9000/?action=snapshot" while True: subprocess.run(["wget", "-O", "photo.jpg", commd], stdout=devnull, stderr=subprocess.STDOUT) with ImageInference(image_classification.model()) as inference: image = Image.open("./photo.jpg") classes = image_classification.get_classes(inference.run(image), max_num_objects=1) for i, (label, score) in enumerate(classes): print('Result %d: %s (prob=%f)' % (i, label, score))