megadetector 5.0.11__py3-none-any.whl → 5.0.12__py3-none-any.whl

megadetector/api/batch_processing/integration/eMammal/test_scripts/push_annotations_to_emammal.py

@@ -0,0 +1,126 @@
+#
+# Test script for pushing annotations to the eMammal db
+#
+
+#%% Imports
+
+import sys
+import json
+import argparse
+import pymysql
+import config as cfg
+
+from tqdm import tqdm
+from enum import Enum
+
+
+#%% Database functions
+
+class Categories(Enum):
+    animal = 1
+    person = 2
+    vehicle = 3
+
+mysql_connection = pymysql.connect( host=cfg.host, 
+                                user=cfg.username, 
+                                passwd=cfg.password, 
+                                db=cfg.database, 
+                                port=cfg.port)
+
+def update_data(sql):
+    with mysql_connection.cursor() as cursor:
+        cursor.execute(sql)
+        
+def get_records_all(sql):
+    with mysql_connection.cursor() as cursor:
+        sql = sql
+        cursor.execute(sql)
+        rows = cursor.fetchall()
+        return rows
+
+def format_data_print_deployments(rows):
+    count = 0
+    result = []
+    for row in rows:
+            count += 1
+            print("{}. {}-{}".format(str(count), row[0],row[1]))
+            result.append((count, row[0], row[1]))
+
+    return result
+
+
+#%% Command-line driver
+
+def main():
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('input_file', type=str, help='Input .json filename')
+   
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+
+    args = parser.parse_args() 
+
+    print("Enter the number of the deployment:")
+    
+    rows = get_records_all(''' select * from deployment ''')
+    deployments = format_data_print_deployments(rows)
+    print("\n")
+    deployment_choice = input()
+    deployment_id = deployments[int(deployment_choice)][1]
+   
+    print(deployment_id)
+
+    # TODO: check project ID ?
+    sql = ''' SELECT emammal_project_taxa_id FROM wild_id.emammal_project_taxa
+            where species in ("No Animal", "Unknown Animal", "Homo sapiens", "Vehicle") '''
+
+
+    emammal_categories = get_records_all(sql)
+
+    with open(args.input_file) as f:
+        data = json.load(f)
+
+    images = data['images']
+    emammal_category = 0
+    for index, im in tqdm(enumerate(images), total=len(images)):      
+        fn = im['file']
+
+        if len(im['detections']) <= 0:
+            image_type_id = 2
+        
+            # No-animal category
+            emammal_categories = emammal_categories[0]
+        else:            
+            max_conf = im['max_detection_conf']
+            detection = [k for k in im['detections'] if k['conf'] == max_conf]
+            category= int(detection[0]['category'])
+
+            if category == Categories.animal:
+                image_type_id = 1
+                emammal_category = emammal_categories[1]
+            else:
+                image_type_id = 5
+                if category == Categories.person:
+                    emammal_category = emammal_categories[2]
+                elif category == Categories.vehicle:
+                    emammal_category = emammal_categories[3]
+
+            sql = """ UPDATE wild_id.emammal_sequence_annotation,
+                      wild_id.image,
+                      wild_id.image_sequence,
+                      wild_id.deployment
+                      SET wild_id.emammal_sequence_annotation.project_taxa_id = 4
+                      WHERE wild_id.image.image_sequence_id = wild_id.emammal_sequence_annotation.sequence_id
+                      AND wild_id.image_sequence.deployment_id = wild_id.deployment.deployment_id
+                      AND wild_id.image.raw_name = '{}' """.format(fn)
+
+            
+            print(sql)
+            update_data(sql)
+            mysql_connection.commit()
+
+if __name__ == '__main__':
+    main()
+

megadetector/api/batch_processing/integration/eMammal/test_scripts/select_images_for_testing.py

@@ -0,0 +1,55 @@
+#%% Imports
+
+import os
+import sys
+import argparse
+import json
+import shutil
+
+from tqdm import tqdm
+
+#%% Main function
+
+def main():
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('input_file', type=str, help='Input .json filename')
+   
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+
+    args = parser.parse_args() 
+
+    with open(args.input_file) as f:
+        data = json.load(f)
+
+    images = data['images'][:1000]
+    data['images'] = images
+    with open('output.json', 'w') as f:
+        json.dump(data, f,  indent=1)
+
+    select_images_folder = "select_images_folder"
+
+    if os.path.exists(select_images_folder):
+        shutil.rmtree(select_images_folder, ignore_errors=True)
+
+    os.mkdir(select_images_folder)
+
+    source = os.getcwd() + "\\SWWLF2019_R1_GMU1_F_9\\"
+    destination = os.getcwd() + "\\" + select_images_folder + "\\"
+
+    # if not os.path.exists(directory):
+    #   os.makedirs(directory)
+
+    for index, im in tqdm(enumerate(images), total=len(images)):
+        fn=im['file']
+        fn = fn.replace('/', '\\')
+        print(os.path.dirname(fn))
+        directory = destination + os.path.dirname(fn)
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        dest = shutil.copyfile(source + fn, destination + fn)         
+
+if __name__ == '__main__':
+    main()

megadetector/api/synchronous/api_core/animal_detection_api/api_backend.py

@@ -0,0 +1,152 @@
+#
+# api_backend.py
+#
+# Defines the model execution service, which pulls requests (one or more images)
+# from the shared Redis queue, and runs them through the TF model.
+#
+
+#%% Imports
+
+import os
+import json
+import time
+import redis
+import argparse
+import PIL
+
+from io import BytesIO
+
+from detection.run_detector import load_detector, convert_to_tf_coords
+import config
+import visualization.visualization_utils as vis_utils 
+
+#%% Initialization
+
+db = redis.StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT)
+current_directory = os.path.dirname(os.path.realpath(__file__))
+
+
+#%% Main loop
+
+def detect_process():
+     
+     while True:
+        
+        # TODO: convert to a blocking read and eliminate the sleep() statement in this loop
+        serialized_entry = db.lpop(config.REDIS_QUEUE_NAME)
+        all_detection_results = []
+        inference_time_detector = []
+        
+        if serialized_entry:
+            
+            entry = json.loads(serialized_entry)
+            id = entry['id']
+            print('Processing images from request id:', id)
+            return_confidence_threshold = entry['return_confidence_threshold']
+
+            try:
+                
+                temp_direc = os.path.join(config.TEMP_FOLDER,id)
+                assert os.path.isdir(temp_direc), 'Could not find temporary folder {}'.format(temp_direc)
+                
+                for filename in os.listdir(temp_direc):
+                    
+                    image_path = f'{temp_direc}/{filename}'
+                    print('Reading image from {}'.format(image_path))
+                    image = open(image_path, 'rb')
+                    image = vis_utils.load_image(image)
+
+                    start_time = time.time()
+                    result = detector.generate_detections_one_image(image, filename, detection_threshold=config.DEFAULT_CONFIDENCE_THRESHOLD)
+                    all_detection_results.append(result)
+
+                    elapsed = time.time() - start_time
+                    inference_time_detector.append(elapsed)
+                    
+            except Exception as e:
+
+                print('Detection error: ' + str(e))
+                
+                db.set(entry['id'], json.dumps({ 
+                    'status': 500,
+                    'error': 'Detection error: ' + str(e)
+                }))
+
+                continue
+
+            # Filter the detections by the confidence threshold
+            #
+            # Each result is [ymin, xmin, ymax, xmax, confidence, category]
+            #
+            # Coordinates are relative, with the origin in the upper-left
+            detections = {}  
+            
+            try:
+                
+                for result in all_detection_results:
+                    
+                    image_name = result['file']
+                    _detections = result.get('detections', None)
+                    detections[image_name] = []
+
+                    if _detections is None:
+                        continue
+
+                    for d in _detections:
+                        if d['conf'] > return_confidence_threshold:
+                            res = convert_to_tf_coords(d['bbox'])
+                            res.append(d['conf'])
+                            res.append(int(d['category']))
+                            detections[image_name].append(res)
+    
+                db.set(entry['id'], json.dumps({ 
+                    'status': 200,
+                    'detections': detections,
+                    'inference_time_detector': inference_time_detector
+                }))
+              
+            except Exception as e:
+                print('Error consolidating the detection boxes: ' + str(e))
+                
+                db.set(entry['id'], json.dumps({ 
+                    'status': 500,
+                    'error': 'Error consolidating the detection boxes:' + str(e)
+                }))
+
+        # ...if serialized_entry
+        
+        else:
+            time.sleep(0.005)
+    
+    # ...while(True)
+    
+# ...def detect_process()    
+        
+
+#%% Command-line driver
+
+if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser(description='api backend')
+
+    # use --non-docker if you are testing without Docker
+    #
+    # python api_frontend.py --non-docker
+    parser.add_argument('--non-docker', action='store_true', default=False)
+    args = parser.parse_args()
+
+    if args.non_docker:
+        model_path = config.DETECTOR_MODEL_PATH_DEBUG
+    else:
+        model_path = config.DETECTOR_MODEL_PATH
+
+    detector = load_detector(model_path)
+
+    # run detections on a test image to load the model
+    print('Running initial detection to load model...')
+    test_image = PIL.Image.new(mode="RGB", size=(200, 200))
+    result = detector.generate_detections_one_image(test_image, "test_image", detection_threshold=config.DEFAULT_CONFIDENCE_THRESHOLD)
+    print(result)
+    print('\n')
+
+    detect_process() 

megadetector/api/synchronous/api_core/animal_detection_api/api_frontend.py

@@ -0,0 +1,266 @@
+# 
+# api_frontend.py
+#
+# Defines the Flask app, which takes requests (one or more images) from
+# remote callers and pushes the images onto the shared Redis queue, to be processed
+# by the main service in api_backend.py .
+#
+
+#%% Imports
+
+import os
+import json
+import time
+import uuid
+import redis
+import shutil
+import argparse
+import traceback
+
+from io import BytesIO
+from flask import Flask, Response, jsonify, make_response, request
+from requests_toolbelt.multipart.encoder import MultipartEncoder
+
+import visualization.visualization_utils as vis_utils
+import config
+
+
+#%% Initialization
+
+app = Flask(__name__)
+db = redis.StrictRedis(host=config.REDIS_HOST, port=config.REDIS_PORT)
+
+
+#%% Support functions
+
+def _make_error_object(error_code, error_message):
+    
+    # Make a dict that the request_processing_function can return to the endpoint 
+    # function to notify it of an error
+    return {
+        'error_message': error_message,
+        'error_code': error_code
+    }
+
+
+def _make_error_response(error_code, error_message):
+
+    return make_response(jsonify({'error': error_message}), error_code)
+
+
+def has_access(request):
+    
+    if not os.path.exists(config.API_KEYS_FILE):
+        return True
+    else:
+        if not request.headers.get('key'):
+            print('Key header not available')
+            return False
+        else:
+            API_key = request.headers.get('key').strip().lower()
+            with open(config.API_KEYS_FILE, "r") as f:
+                for line in f:
+                    valid_key = line.strip().lower()
+                    if valid_key == API_key:
+                        return True
+
+    return False
+
+
+def check_posted_data(request):
+ 
+    files = request.files
+    params = request.args
+
+    # Verify that the content uploaded is not too big
+    #
+    # request.content_length is the length of the total payload
+    content_length = request.content_length
+    if not content_length:
+        return _make_error_object(411, 'No image(s) were sent, or content length cannot be determined.')
+    if content_length > config.MAX_CONTENT_LENGTH_IN_MB * 1024 * 1024:
+        return _make_error_object(413, ('Payload size {:.2f} MB exceeds the maximum allowed of {} MB. '
+                    'Please upload fewer or more compressed images.').format(
+            content_length / (1024 * 1024), config.MAX_CONTENT_LENGTH_IN_MB))
+
+    render_boxes = True if params.get('render', '').lower() == 'true' else False
+
+    if 'min_confidence' in params:
+        return_confidence_threshold = float(params['min_confidence'])
+        print('runserver, post_detect_sync, user specified detection confidence: ', return_confidence_threshold)
+        if return_confidence_threshold < 0.0 or return_confidence_threshold > 1.0:
+            return _make_error_object(400, 'Detection confidence threshold {} is invalid, should be between 0.0 and 1.0.'.format(
+                return_confidence_threshold))
+    else:
+        return_confidence_threshold = config.DEFAULT_CONFIDENCE_THRESHOLD
+        
+    if 'min_rendering_confidence' in params:
+        rendering_confidence_threshold = float(params['min_rendering_confidence'])
+        print('runserver, post_detect_sync, user specified rendering confidence: ', rendering_confidence_threshold) 
+        if rendering_confidence_threshold < 0.0 or rendering_confidence_threshold > 1.0:
+            return _make_error_object(400, 'Rendering confidence threshold {} is invalid, should be between 0.0 and 1.0.'.format(
+                rendering_confidence_threshold))
+    else:
+        rendering_confidence_threshold =  config.DEFAULT_RENDERING_CONFIDENCE_THRESHOLD
+    
+    # Verify that the number of images is acceptable
+    num_images = sum([1 if file.content_type in config.IMAGE_CONTENT_TYPES else 0 for file in files.values()])
+    print('runserver, post_detect_sync, number of images received: ', num_images)
+
+    if num_images > config.MAX_IMAGES_ACCEPTED:
+        return _make_error_object(413, 'Too many images. Maximum number of images that can be processed in one call is {}.'.format(config.MAX_IMAGES_ACCEPTED))
+    elif num_images == 0:
+        return _make_error_object(400, 'No image(s) of accepted types (image/jpeg, image/png, application/octet-stream) received.')
+    
+    return {
+        'render_boxes': render_boxes,
+        'return_confidence_threshold': return_confidence_threshold,
+        'rendering_confidence_threshold': rendering_confidence_threshold
+    }
+
+# ...def check_posted_data(request)
+    
+
+#%% Main loop
+
+@app.route(config.API_PREFIX + '/detect', methods = ['POST'])
+def detect_sync():
+    
+    if not has_access(request):
+        print('Access denied, please provide a valid API key')
+        return _make_error_response(403, 'Access denied, please provide a valid API key')
+
+    # Check whether the request_processing_function had an error
+    post_data = check_posted_data(request)
+    if post_data.get('error_code', None) is not None:
+        return _make_error_response(post_data.get('error_code'), post_data.get('error_message'))
+
+    render_boxes = post_data.get('render_boxes')
+    return_confidence_threshold = post_data.get('return_confidence_threshold')
+    rendering_confidence_threshold = post_data.get('rendering_confidence_threshold')
+  
+    redis_id = str(uuid.uuid4())
+    d = {'id': redis_id, 'render_boxes': render_boxes, 'return_confidence_threshold': return_confidence_threshold}
+    temp_direc = os.path.join(config.TEMP_FOLDER, redis_id)
+    
+    try:
+        
+        try:
+            # Write images to temporary files
+            #
+            # TODO: read from memory rather than using intermediate files
+            os.makedirs(temp_direc,exist_ok=True)
+            for name, file in request.files.items():
+                if file.content_type in config.IMAGE_CONTENT_TYPES:
+                    filename = request.files[name].filename
+                    image_path = os.path.join(temp_direc, filename)
+                    print('Saving image {} to {}'.format(name,image_path))
+                    file.save(image_path)
+                    assert os.path.isfile(image_path),'Error creating file {}'.format(image_path)
+        
+        except Exception as e:
+            return _make_error_object(500, 'Error saving images: ' + str(e))
+        
+        # Submit the image(s) for processing by api_backend.py, who is waiting on this queue
+        db.rpush(config.REDIS_QUEUE_NAME, json.dumps(d))
+        
+        while True:
+            
+            # TODO: convert to a blocking read and eliminate the sleep() statement in this loop
+            result = db.get(redis_id)
+            
+            if result:
+                
+                result = json.loads(result.decode())
+                print('Processing result {}'.format(str(result)))
+                
+                if result['status'] == 200:
+                    detections = result['detections']
+                    db.delete(redis_id)
+                
+                else:
+                    db.delete(redis_id)
+                    print('Detection error: ' + str(result))
+                    return _make_error_response(500, 'Detection error: ' + str(result))
+
+                try:
+                    print('detect_sync: postprocessing and sending images back...')
+                    fields = {
+                        'detection_result': ('detection_result', json.dumps(detections), 'application/json'),
+                    }
+
+                    if render_boxes and result['status'] == 200:
+
+                        print('Rendering images')
+
+                        for image_name, detections in detections.items():
+                            
+                            #image = Image.open(os.path.join(temp_direc, image_name))
+                            image = open(f'{temp_direc}/{image_name}', "rb")
+                            image = vis_utils.load_image(image)
+                            width, height = image.size
+
+                            _detections = []
+                            for d in detections:
+                                y1,x1,y2,x2 = d[0:4]
+                                width = x2 - x1
+                                height = y2 - y1
+                                bbox = [x1,y1,width,height]
+                                _detections.append({'bbox': bbox, 'conf': d[4], 'category': d[5]}) 
+                            
+                            vis_utils.render_detection_bounding_boxes(_detections, image, 
+                            confidence_threshold=rendering_confidence_threshold)
+                            
+                            output_img_stream = BytesIO()
+                            image.save(output_img_stream, format='jpeg')
+                            output_img_stream.seek(0)
+                            fields[image_name] = (image_name, output_img_stream, 'image/jpeg')
+                        print('Done rendering images')
+                        
+                    m = MultipartEncoder(fields=fields)                    
+                    return Response(m.to_string(), mimetype=m.content_type)
+
+                except Exception as e:
+                    
+                    print(traceback.format_exc())
+                    print('Error returning result or rendering the detection boxes: ' + str(e))
+
+                finally:
+                    
+                    try:
+                        print('Removing temporary files')
+                        shutil.rmtree(temp_direc)
+                    except Exception as e:
+                        print('Error removing temporary folder {}: {}'.format(temp_direc,str(e)))
+                    
+            else:
+                time.sleep(0.005)
+                
+            # ...if we do/don't have a request available on the queue
+            
+        # ...while(True)
+
+    except Exception as e:
+        
+        print(traceback.format_exc())
+        return _make_error_object(500, 'Error processing images: ' + str(e))
+
+# ...def detect_sync()
+
+
+#%% Command-line driver
+    
+if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser(description='api frontend')
+
+    # use --non-docker if you are testing without Docker
+    #
+    # python api_frontend.py --non-docker
+    parser.add_argument('--non-docker', action="store_true", default=False)
+    args = parser.parse_args()
+
+    if args.non_docker:
+        app.run(host='0.0.0.0', port=5050)
+    else:
+        app.run()

megadetector/api/synchronous/api_core/animal_detection_api/config.py

@@ -0,0 +1,35 @@
+## Camera trap real-time API configuration
+
+REDIS_HOST = 'localhost'
+
+REDIS_PORT = 6379
+
+# Full path to the temporary folder for image storage, only meaningful 
+# within the Docker container
+TEMP_FOLDER = '/app/temp'
+
+REDIS_QUEUE_NAME = 'camera-trap-queue'
+
+# Upper limit on total content length (all images and parameters)
+MAX_CONTENT_LENGTH_IN_MB = 5 * 8  # 5MB per image * number of images allowed
+
+MAX_IMAGES_ACCEPTED = 8
+
+IMAGE_CONTENT_TYPES = ['image/png', 'application/octet-stream', 'image/jpeg']
+
+DETECTOR_MODEL_PATH = '/app/animal_detection_api/model/md_v5a.0.0.pt'
+
+DETECTOR_MODEL_VERSION = 'v5a.0.0'
+
+# Minimum confidence threshold for detections
+DEFAULT_CONFIDENCE_THRESHOLD = 0.01
+
+# Minimum confidence threshold for showing a bounding box on the output image
+DEFAULT_RENDERING_CONFIDENCE_THRESHOLD = 0.2
+
+API_PREFIX = '/v1/camera-trap/sync'
+
+API_KEYS_FILE = 'allowed_keys.txt'
+
+# Use this when testing without Docker
+DETECTOR_MODEL_PATH_DEBUG = 'model/md_v5a.0.0.pt'