megadetector 5.0.6__py3-none-any.whl → 5.0.8__py3-none-any.whl

md_visualization/visualize_db.py

@@ -16,18 +16,21 @@ import math
 import os
 import sys
 import time
+
+import pandas as pd
+import numpy as np
+
+import humanfriendly
+
 from itertools import compress
 from multiprocessing.pool import ThreadPool
 from multiprocessing.pool import Pool
-
-import pandas as pd
 from tqdm import tqdm
-import humanfriendly
 
 from md_utils.write_html_image_list import write_html_image_list
+from data_management.cct_json_utils import IndexedJsonDb
 
 import md_visualization.visualization_utils as vis_utils
-from data_management.cct_json_utils import IndexedJsonDb
 
 
 #%% Settings
@@ -40,8 +43,16 @@ class DbVizOptions:
     # Target size for rendering; set either dimension to -1 to preserve aspect ratio
     #
     # If viz_size is None or (-1,-1), the original image size is used.
-    viz_size = (675, -1)
+    viz_size = (800, -1)
+    
+    # The most relevant option one might want to set here is:
+    #
+    # htmlOptions['maxFiguresPerHtmlFile']
+    #
+    # ...which can be used to paginate previews to a number of images that will load well
+    # in a browser (5000 is a reasonable limit).
     htmlOptions = write_html_image_list()
+    
     sort_by_filename = True
     trim_to_images_with_bboxes = False
     
@@ -82,6 +93,11 @@ class DbVizOptions:
     # Should we show absolute (vs. relative) paths for each image?
     show_full_paths = False
     
+    # Set to False to skip existing images
+    force_rendering = True
+    
+    verbose = False
+    
 
 #%% Helper functions
 
@@ -264,7 +280,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
             categoryName = label_map[categoryID]
             if options.add_search_links:
                 categoryName = categoryName.replace('"','')
-                categoryName = '<a href="https://www.bing.com/images/search?q={}">{}</a>'.format(
+                categoryName = '<a href="https://www.google.com/search?tbm=isch&q={}">{}</a>'.format(
                     categoryName,categoryName)
             imageCategories.add(categoryName)
             
@@ -309,14 +325,22 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         if options.include_filename_links:
             filename_text = '<a href="{}">{}</a>'.format(img_path,filename_text)
             
+        flagString = ''
+        
+        def isnan(x):
+            return (isinstance(x,float) and np.isnan(x))
+        
+        if ('flags' in img) and (not isnan(img['flags'])):
+            flagString = ', flags: {}'.format(str(img['flags']))
+            
         # We're adding html for an image before we render it, so it's possible this image will
         # fail to render.  For applications where this script is being used to debua a database
         # (the common case?), this is useful behavior, for other applications, this is annoying.
         image_dict = \
         {
             'filename': '{}/{}'.format('rendered_images', file_name),
-            'title': '{}<br/>{}, num boxes: {}, {}class labels: {}{}'.format(
-                filename_text, img_id, len(bboxes), frameString, imageClasses, labelLevelString),
+            'title': '{}<br/>{}, num boxes: {}, {}class labels: {}{}{}'.format(
+                filename_text, img_id, len(bboxes), frameString, imageClasses, labelLevelString, flagString),
             'textStyle': 'font-family:verdana,arial,calibri;font-size:80%;' + \
                 'text-align:left;margin-top:20;margin-bottom:5'
         }
@@ -333,7 +357,13 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         bboxes = rendering_info['bboxes']
         bboxClasses = rendering_info['boxClasses']
         output_file_name = rendering_info['output_file_name']
+        output_full_path = os.path.join(output_dir, 'rendered_images', output_file_name)
         
+        if (os.path.isfile(output_full_path)) and (not options.force_rendering):
+            if options.verbose:
+                print('Skipping existing image {}'.format(output_full_path))
+            return True
+            
         if not img_path.startswith('http'):
             if not os.path.exists(img_path):
                 print('Image {} cannot be found'.format(img_path))
@@ -348,7 +378,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
                 image = vis_utils.resize_image(original_image, options.viz_size[0],
                                                options.viz_size[1])
         except Exception as e:
-            print('Image {} failed to open. Error: {}'.format(img_path, e))
+            print('Image {} failed to open, error: {}'.format(img_path, e))
             return False
             
         vis_utils.render_db_bounding_boxes(boxes=bboxes, classes=bboxClasses,
@@ -357,7 +387,8 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
                                            thickness=options.box_thickness,
                                            expansion=options.box_expansion)
         
-        image.save(os.path.join(output_dir, 'rendered_images', output_file_name))
+        image.save(output_full_path)
+                
         return True
     
     # ...def render_image_info

md_visualization/visualize_detector_output.py

@@ -3,8 +3,7 @@
 # visualize_detector_output.py
 #
 # Render images with bounding boxes annotated on them to a folder, based on a
-# detector output result file (json). The original images can be local or in
-# Azure Blob Storage.
+# detector output result file (json), optionally writing an HTML index file.
 #
 ########
 
@@ -15,51 +14,115 @@ import json
 import os
 import random
 import sys
-from typing import List, Optional
+from multiprocessing.pool import ThreadPool
+from multiprocessing.pool import Pool
+from typing import List
+from functools import partial
 
 from tqdm import tqdm
 
-from data_management.annotations.annotation_constants import (
-    detector_bbox_category_id_to_name)  # here id is int
+from data_management.annotations.annotation_constants import detector_bbox_category_id_to_name
 from md_visualization import visualization_utils as vis_utils
 from md_utils.ct_utils import get_max_conf
+from md_utils import write_html_image_list
+from detection.run_detector import get_typical_confidence_threshold_from_results
 
 
 #%% Constants
 
-# convert category ID from int to str
+# This will only be used if a category mapping is not available in the results file.
 DEFAULT_DETECTOR_LABEL_MAP = {
     str(k): v for k, v in detector_bbox_category_id_to_name.items()
 }
 
 
+#%% Support functions
+
+def render_image(entry,
+                 detector_label_map,classification_label_map,
+                 confidence_threshold,classification_confidence_threshold,
+                 render_detections_only,preserve_path_structure,out_dir,images_dir,
+                 output_image_width):
+    
+    rendering_result = {'failed_image':False,'missing_image':False,
+                        'skipped_image':False,'annotated_image_path':None,
+                        'max_conf':None,'file':entry['file']}
+    
+    image_id = entry['file']
+
+    if 'failure' in entry and entry['failure'] is not None:
+        rendering_result['failed_image'] = True
+        return rendering_result
+
+    assert 'detections' in entry and entry['detections'] is not None
+    
+    max_conf = get_max_conf(entry)
+    rendering_result['max_conf'] = max_conf
+    
+    if (max_conf < confidence_threshold) and render_detections_only:
+        rendering_result['skipped_image'] = True
+        return rendering_result
+    
+    image_obj = os.path.join(images_dir, image_id)
+    if not os.path.exists(image_obj):
+        print(f'Image {image_id} not found in images_dir')
+        rendering_result['missing_image'] = True
+        return rendering_result
+
+    # If output_image_width is -1 or None, this will just return the original image
+    image = vis_utils.resize_image(
+        vis_utils.open_image(image_obj), output_image_width)
+
+    vis_utils.render_detection_bounding_boxes(
+        entry['detections'], image, 
+        label_map=detector_label_map,
+        classification_label_map=classification_label_map,
+        confidence_threshold=confidence_threshold,
+        classification_confidence_threshold=classification_confidence_threshold)
+
+    if not preserve_path_structure:
+        for char in ['/', '\\', ':']:
+            image_id = image_id.replace(char, '~')
+        annotated_img_path = os.path.join(out_dir, f'anno_{image_id}')
+    else:
+        assert not os.path.isabs(image_id), "Can't preserve paths when operating on absolute paths"
+        annotated_img_path = os.path.join(out_dir, image_id)
+        os.makedirs(os.path.dirname(annotated_img_path),exist_ok=True)
+        
+    image.save(annotated_img_path)
+    rendering_result['annotated_image_path'] = annotated_img_path        
+
+    return rendering_result
+
+
 #%% Main function
 
 def visualize_detector_output(detector_output_path: str,
                               out_dir: str,
                               images_dir: str,
-                              is_azure: bool = False,
                               confidence_threshold: float = 0.15,
                               sample: int = -1,
                               output_image_width: int = 700,
-                              random_seed: Optional[int] = None,
+                              random_seed: int = None,
                               render_detections_only: bool = False,
                               classification_confidence_threshold = 0.1,
                               html_output_file = None,
                               html_output_options = None,
-                              preserve_path_structure = False) -> List[str]:
+                              preserve_path_structure = False,
+                              parallelize_rendering = False,
+                              parallelize_rendering_n_cores = 10,
+                              parallelize_rendering_with_threads = True) -> List[str]:
     
     """
-    Draw bounding boxes on images given the output of the detector.
+    Draw bounding boxes on images given the output of a detector.
 
     Args:
         detector_output_path: str, path to detector output json file
         out_dir: str, path to directory for saving annotated images
-        images_dir: str, path to local images dir, or a SAS URL to an Azure Blob
-            Storage container
-        is_azure: bool, whether images_dir points to an Azure URL
+        images_dir: str, path to images dir
         confidence: float, threshold above which annotations will be rendered
         sample: int, maximum number of images to annotate, -1 for all
+        random_seed: seed for sampling (not relevant if sample == -1)
         output_image_width: int, width in pixels to resize images for display,
             set to -1 to use original image width
         random_seed: int, for deterministic image sampling when sample != -1
@@ -68,16 +131,11 @@ def visualize_detector_output(detector_output_path: str,
     Returns: list of str, paths to annotated images
     """
     
-    assert confidence_threshold >= 0 and confidence_threshold <= 1, (
-        f'Confidence threshold {confidence_threshold} is invalid, must be in (0, 1).')
-
-    assert os.path.exists(detector_output_path), (
-        f'Detector output file does not exist at {detector_output_path}.')
+    assert os.path.exists(detector_output_path), \
+        'Detector output file does not exist at {}'.format(detector_output_path)
 
-    if is_azure:
-        from md_utils import sas_blob_utils
-    else:
-        assert os.path.isdir(images_dir)
+    assert os.path.isdir(images_dir), \
+        'Image folder {} is not available'.format(images_dir)
 
     os.makedirs(out_dir, exist_ok=True)
 
@@ -89,12 +147,18 @@ def visualize_detector_output(detector_output_path: str,
     assert 'images' in detector_output, (
         'Detector output file should be a json with an "images" field.')
     images = detector_output['images']
-
+    
+    if confidence_threshold is None:
+        confidence_threshold = get_typical_confidence_threshold_from_results(detector_output)
+        
+    assert confidence_threshold >= 0 and confidence_threshold <= 1, (
+        f'Confidence threshold {confidence_threshold} is invalid, must be in (0, 1).')
+    
     if 'detection_categories' in detector_output:
         print('Using custom label mapping')
         detector_label_map = detector_output['detection_categories']
     else:
-        detector_label_map = DEFAULT_DETECTOR_LABEL_MAP        
+        detector_label_map = DEFAULT_DETECTOR_LABEL_MAP
 
     num_images = len(images)
     print(f'Detector output file contains {num_images} entries.')
@@ -118,85 +182,89 @@ def visualize_detector_output(detector_output_path: str,
     print('Rendering detections above a confidence threshold of {}'.format(
         confidence_threshold))
     
-    num_saved = 0
-    annotated_img_paths = []
-    failed_images = []
-    missing_images = []
-    
     classification_label_map = None
     
     if 'classification_categories' in detector_output:
         classification_label_map = detector_output['classification_categories']
         
-    for entry in tqdm(images):
-        
-        image_id = entry['file']
-
-        if 'failure' in entry and entry['failure'] is not None:
-            failed_images.append(image_id)
-            continue
-
-        assert 'detections' in entry and entry['detections'] is not None
-        
-        max_conf = get_max_conf(entry)
-        if (max_conf < confidence_threshold) and render_detections_only:
-            continue
+    rendering_results = []
+    
+    if parallelize_rendering:
         
-        if is_azure:
-            blob_uri = sas_blob_utils.build_blob_uri(
-                container_uri=images_dir, blob_name=image_id)
-            if not sas_blob_utils.check_blob_exists(blob_uri):
-                container = sas_blob_utils.get_container_from_uri(images_dir)
-                print(f'Image {image_id} not found in blob container '
-                      f'{container}; skipped.')
-                continue
-            # BytesIO object
-            image_obj, _ = sas_blob_utils.download_blob_to_stream(blob_uri)
+        if parallelize_rendering_with_threads:
+            worker_string = 'threads'
         else:
-            image_obj = os.path.join(images_dir, image_id)
-            if not os.path.exists(image_obj):
-                print(f'Image {image_id} not found in images_dir')
-                missing_images.append(image_id)
-                continue
-
-        image = vis_utils.resize_image(
-            vis_utils.open_image(image_obj), output_image_width)
-
-        vis_utils.render_detection_bounding_boxes(
-            entry['detections'], image, label_map=detector_label_map,
-            classification_label_map = classification_label_map,
-            confidence_threshold=confidence_threshold,
-            classification_confidence_threshold=classification_confidence_threshold)
-
-        if not preserve_path_structure:
-            for char in ['/', '\\', ':']:
-                image_id = image_id.replace(char, '~')
-            annotated_img_path = os.path.join(out_dir, f'anno_{image_id}')
+            worker_string = 'processes'
+            
+        if parallelize_rendering_n_cores is None:
+            if parallelize_rendering_with_threads:
+                pool = ThreadPool()
+            else:
+                pool = Pool()
         else:
-            assert not os.path.isabs(image_id), "Can't preserve paths when operating on absolute paths"
-            annotated_img_path = os.path.join(out_dir, image_id)
-            os.makedirs(os.path.dirname(annotated_img_path),exist_ok=True)
-        annotated_img_paths.append(annotated_img_path)
-        image.save(annotated_img_path)
-        num_saved += 1
-
-        if is_azure:
-            image_obj.close()
-
+            if parallelize_rendering_with_threads:
+                pool = ThreadPool(parallelize_rendering_n_cores)
+            else:
+                pool = Pool(parallelize_rendering_n_cores)
+            print('Rendering images with {} {}'.format(parallelize_rendering_n_cores,
+                                                       worker_string))            
+        rendering_results = list(tqdm(pool.imap(
+                                 partial(render_image,detector_label_map=detector_label_map,
+                                         classification_label_map=classification_label_map,
+                                         confidence_threshold=confidence_threshold,
+                                         classification_confidence_threshold=classification_confidence_threshold,
+                                         render_detections_only=render_detections_only,
+                                         preserve_path_structure=preserve_path_structure,
+                                         out_dir=out_dir,
+                                         images_dir=images_dir,
+                                         output_image_width=output_image_width),
+                                 images), total=len(images)))
+        
+    else:
+                
+        for entry in tqdm(images):
+            
+            rendering_result = render_image(entry,detector_label_map,classification_label_map,
+                                            confidence_threshold,classification_confidence_threshold,
+                                            render_detections_only,preserve_path_structure,out_dir,
+                                            images_dir,output_image_width)
+            rendering_results.append(rendering_result)
+        
     # ...for each image
     
+    failed_images = [r for r in rendering_results if r['failed_image']]
+    missing_images = [r for r in rendering_results if r['missing_image']]
+    skipped_images = [r for r in rendering_results if r['skipped_image']]
+    
     print('Skipped {} failed images (of {})'.format(len(failed_images),len(images)))
     print('Skipped {} missing images (of {})'.format(len(missing_images),len(images)))
+    print('Skipped {} below-threshold images (of {})'.format(len(skipped_images),len(images)))
     
-    print(f'Rendered detection results on {num_saved} images, '
-          f'saved to {out_dir}')
+    print(f'Rendered detection results to {out_dir}')
 
+    annotated_image_paths = [r['annotated_image_path'] for r in rendering_results if \
+                             r['annotated_image_path'] is not None]
+    
     if html_output_file is not None:
-        from md_utils import write_html_image_list
-        write_html_image_list.write_html_image_list(html_output_file,annotated_img_paths,
+        
+        html_dir = os.path.dirname(html_output_file)
+        
+        html_image_info = []
+        
+        for r in rendering_results:
+            d = {}
+            annotated_image_path_relative = os.path.relpath(r['annotated_image_path'],html_dir)
+            d['filename'] = annotated_image_path_relative
+            d['textStyle'] = \
+             'font-family:verdana,arial,calibri;font-size:80%;' + \
+                 'text-align:left;margin-top:20;margin-bottom:5'
+            d['title'] = '{} (max conf: {})'.format(r['file'],r['max_conf'])
+            html_image_info.append(d)
+            
+        _ = write_html_image_list.write_html_image_list(html_output_file,html_image_info,
                                                     options=html_output_options)
         
-    return annotated_img_paths
+    return annotated_image_paths
 
 
 #%% Command-line driver
@@ -221,15 +289,9 @@ def main() -> None:
              'above which to visualize bounding boxes')
     parser.add_argument(
         '-i', '--images_dir', type=str, default=None,
-        help='Path to a local directory or a SAS URL (in double quotes) to an '
-             'Azure blob storage container where images are stored. This '
+        help='Path to a local directory where images are stored. This '
              'serves as the root directory for image paths in '
-             'detector_output_path. If an Azure URL, pass the -a/--is-azure '
-             'flag. You can use Azure Storage Explorer to obtain a SAS URL.')
-    parser.add_argument(
-        '-a', '--is-azure', action='store_true',
-        help='Flag that indidcates images_dir is an Azure blob storage '
-             'container URL.')
+             'detector_output_path.')
     parser.add_argument(
         '-n', '--sample', type=int, default=-1,
         help='Number of images to be annotated and rendered. Set to -1 '
@@ -266,7 +328,6 @@ def main() -> None:
         out_dir=args.out_dir,
         confidence_threshold=args.confidence,
         images_dir=args.images_dir,
-        is_azure=args.is_azure,
         sample=args.sample,
         output_image_width=args.output_image_width,
         random_seed=args.random_seed,
@@ -290,17 +351,37 @@ if False:
 
     #%%
     
-    detector_output_path = r"g:\temp\animl-runs\animl-runs\Coati_v2\manifest.csv.json"
+    detector_output_path = os.path.expanduser('~/postprocessing/bellevue-camera-traps/bellevue-camera-traps-2023-12-05-v5a.0.0/combined_api_outputs/bellevue-camera-traps-2023-12-05-v5a.0.0_detections.json')
     out_dir = r'g:\temp\preview'
-    images_dir = r"g:\temp\animl-runs\animl-runs\Coati_v2"
-    is_azure = False
+    images_dir = r'g:\camera_traps\camera_trap_images'
     confidence_threshold = 0.15
-    sample = -1
+    sample = 50
     output_image_width = 700
-    random_seed = None
-    render_detections_only = False
+    random_seed = 1
+    render_detections_only = True
     classification_confidence_threshold = 0.1
-    html_output_file = None
-    html_output_options = None,
+    html_output_file = os.path.join(out_dir,'index.html')
+    html_output_options = None
     preserve_path_structure = False
-        
+    parallelize_rendering = True
+    parallelize_rendering_n_cores = 10
+    parallelize_rendering_with_threads = False
+
+    _ = visualize_detector_output(detector_output_path,
+                              out_dir,
+                              images_dir,
+                              confidence_threshold,
+                              sample,
+                              output_image_width,
+                              random_seed,
+                              render_detections_only,
+                              classification_confidence_threshold,
+                              html_output_file,
+                              html_output_options,
+                              preserve_path_structure,
+                              parallelize_rendering,
+                              parallelize_rendering_n_cores,
+                              parallelize_rendering_with_threads)
+    
+    from md_utils.path_utils import open_file
+    open_file(html_output_file)

{megadetector-5.0.6.dist-info → megadetector-5.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.6
+Version: 5.0.8
 Summary: MegaDetector is an AI model that helps conservation folks spend less time doing boring things with camera trap images.
 Author-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
 Maintainer-email: Your friendly neighborhood MegaDetector team <cameratraps@lila.science>
@@ -60,7 +60,7 @@ If you want to learn more about what MegaDetector is all about, head over to the
 
 ### If you are an ecologist...
 
-If you are an ecologist looking to use MegaDetector to help you get through your camera trap images, you probably don't want this package.  We recommend starting with our "[Getting started with MegaDetector](https://github.com/agentmorris/MegaDetector/blob/main/collaborations.md)" page, then digging in to the [MegaDetector User Guide](https://github.com/agentmorris/MegaDetector/blob/main/megadetector.md), which will walk you through the process of using MegaDetector.  That journey will <i>not</i> involve this package.
+If you are an ecologist looking to use MegaDetector to help you get through your camera trap images, you probably don't want this package.  We recommend starting with our "[Getting started with MegaDetector](https://github.com/agentmorris/MegaDetector/blob/main/collaborations.md)" page, then digging in to the [MegaDetector User Guide](https://github.com/agentmorris/MegaDetector/blob/main/megadetector.md), which will walk you through the process of using MegaDetector.  That journey will <i>not</i> involve this Python package.
 
 ### If you are a computer-vision-y type...
 
@@ -68,7 +68,7 @@ If you are a computer-vision-y person looking to run or fine-tune MegaDetector p
 
 ## Reasons you might want to use this package
 
-If you want to programatically interact with the postprocessing tools from the MegaDetector repo, or programmatically run MegaDetector in a way that produces [Timelapse](https://saul.cpsc.ucalgary.ca/timelapse)-friendly output (i.e., output in the standard [MegaDetector output format](https://github.com/agentmorris/MegaDetector/tree/main/api/batch_processing#megadetector-batch-output-format)), this package might be for you.
+If you want to programmatically interact with the postprocessing tools from the MegaDetector repo, or programmatically run MegaDetector in a way that produces [Timelapse](https://saul.cpsc.ucalgary.ca/timelapse)-friendly output (i.e., output in the standard [MegaDetector output format](https://github.com/agentmorris/MegaDetector/tree/main/api/batch_processing#megadetector-batch-output-format)), this package might be for you.
 
 Although even if that describes you, you <i>still</i> might be better off cloning the MegaDetector repo.  Pip-installability requires that some dependencies be newer than what was available at the time MDv5 was trained, so results are <i>very slightly</i> different than results produced in the "official" environment.  These differences <i>probably</i> don't matter much, but they have not been formally characterized.
 
@@ -95,15 +95,13 @@ temporary_filename = url_utils.download_url(image_url)
 
 image = vis_utils.load_image(temporary_filename)
 
-# This will automatically download MDv5a to the system temp folder;
-# you can also specify a filename explicitly, or set the $MDV5A
-# environment variable to point to the model file.
+# This will automatically download MDv5a; you can also specify a filename.
 model = run_detector.load_detector('MDV5A')
 
 result = model.generate_detections_one_image(image)
 
 detections_above_threshold = [d for d in result['detections'] if d['conf'] > 0.2]
-print('Found {} detection above threshold'.format(len(detections_above_threshold)))
+print('Found {} detections above threshold'.format(len(detections_above_threshold)))
 ```
 
 #### Run MegaDetector on a folder of images
@@ -120,14 +118,14 @@ output_file = os.path.expanduser('~/megadetector_output_test.json')
 # Recursively find images
 image_file_names = path_utils.find_images(image_folder,recursive=True)
 
-# This will automatically download MDv5a to the system temp folder;
-# you can also specify a filename explicitly, or set the $MDV5A
-# environment variable to point to the model file.
+# This will automatically download MDv5a; you can also specify a filename.
 results = load_and_run_detector_batch('MDV5A', image_file_names)
 
-# Write results as relative filenames, this is what Timelapse
-# and other downstream tools expect.
-write_results_to_file(results,output_file,relative_path_base=image_folder)
+# Write results to a format that Timelapse and other downstream tools like.
+write_results_to_file(results,
+                      output_file,
+                      relative_path_base=image_folder,
+                      detector_file=detector_filename)
 ```
 
 ## Contact