megadetector 5.0.5__py3-none-any.whl → 5.0.7__py3-none-any.whl

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]:
+                              html_output_file = None,
+                              html_output_options = None,
+                              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), \
+        'Detector output file does not exist at {}'.format(detector_output_path)
 
-    assert os.path.exists(detector_output_path), (
-        f'Detector output file does not exist at {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 '
@@ -245,6 +307,9 @@ def main() -> None:
     parser.add_argument(
         '-html', '--html_output_file', type=str, default=None,
         help='Filename to which we should write an HTML image index (off by default)')
+    parser.add_argument(
+        '--open_html_output_file', action='store_true',
+        help='Open the .html output file when done')
     parser.add_argument(
         '-do', '--detections_only', action='store_true',
         help='Only render images with above-threshold detections (by default, '
@@ -263,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,
@@ -271,6 +335,53 @@ def main() -> None:
         preserve_path_structure=args.preserve_path_structure,
         html_output_file=args.html_output_file)
 
+    if args.html_output_file is not None and args.open_html_output_file:
+        from md_utils.path_utils import open_file
+        open_file(args.html_output_file)
 
 if __name__ == '__main__':
     main()
+
+
+#%% Interactive driver
+
+if False:
+    
+    pass
+
+    #%%
+    
+    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:\camera_traps\camera_trap_images'
+    confidence_threshold = 0.15
+    sample = 50
+    output_image_width = 700
+    random_seed = 1
+    render_detections_only = True
+    classification_confidence_threshold = 0.1
+    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.5.dist-info → megadetector-5.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.5
+Version: 5.0.7
 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>
@@ -47,10 +47,7 @@ Requires-Dist: seaborn >=0.12.2
 Requires-Dist: scikit-learn >=1.3.1
 Requires-Dist: pandas >=2.1.1
 Requires-Dist: PyYAML >=6.0.1
-Requires-Dist: torch >=2.0.1
-Requires-Dist: torchvision >=0.15.2
-Requires-Dist: ultralytics ==8.0.186
-Requires-Dist: yolov5 ==7.0.12
+Requires-Dist: ultralytics-yolov5 ==0.1.1
 
 # MegaDetector
 
@@ -71,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.