megadetector 5.0.27__py3-none-any.whl → 5.0.29__py3-none-any.whl

megadetector/visualization/visualize_detector_output.py

@@ -10,7 +10,6 @@ detector output result file (.json), optionally writing an HTML index file.
 #%% Imports
 
 import argparse
-import json
 import os
 import random
 import sys
@@ -21,11 +20,13 @@ from functools import partial
 from tqdm import tqdm
 
 from megadetector.data_management.annotations.annotation_constants import detector_bbox_category_id_to_name
-from megadetector.visualization import visualization_utils as vis_utils
-from megadetector.visualization.visualization_utils import blur_detections
+from megadetector.detection.run_detector import get_typical_confidence_threshold_from_results
 from megadetector.utils.ct_utils import get_max_conf
 from megadetector.utils import write_html_image_list
-from megadetector.detection.run_detector import get_typical_confidence_threshold_from_results
+from megadetector.utils.path_utils import path_is_abs
+from megadetector.utils.wi_utils import load_md_or_speciesnet_file
+from megadetector.visualization import visualization_utils as vis_utils
+from megadetector.visualization.visualization_utils import blur_detections
 
 
 #%% Constants
@@ -53,11 +54,11 @@ def _render_image(entry,
     """
     Internal function for rendering a single image.
     """
-    
+
     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:
@@ -65,23 +66,30 @@ def _render_image(entry,
         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_filename_in_abs = os.path.join(images_dir, image_id)
+
+    if images_dir is None:
+        image_filename_in_abs = image_id
+        assert path_is_abs(image_filename_in_abs), \
+            'Absolute paths are required when no image base dir is supplied'
+    else:
+        assert not path_is_abs(image_id), \
+            'Relative paths are required when an image base dir is supplied'
+        image_filename_in_abs = os.path.join(images_dir, image_id)
     if not os.path.exists(image_filename_in_abs):
-        print(f'Image {image_id} not found in images_dir')
+        print(f'Image {image_id} not found')
         rendering_result['missing_image'] = True
         return rendering_result
 
     # Load the image
     image = vis_utils.open_image(image_filename_in_abs)
-    
+
     # Find categories we're supposed to blur
     category_ids_to_blur = []
     if category_names_to_blur is not None:
@@ -90,21 +98,21 @@ def _render_image(entry,
         for category_id in detector_label_map:
             if detector_label_map[category_id] in category_names_to_blur:
                 category_ids_to_blur.append(category_id)
-    
+
     detections_to_blur = []
     for d in entry['detections']:
         if d['conf'] >= confidence_threshold and d['category'] in category_ids_to_blur:
             detections_to_blur.append(d)
     if len(detections_to_blur) > 0:
         blur_detections(image,detections_to_blur)
-        
+
     # Resize if necessary
     #
     # If output_image_width is -1 or None, this will just return the original image
     image = vis_utils.resize_image(image, output_image_width)
 
     vis_utils.render_detection_bounding_boxes(
-        entry['detections'], image, 
+        entry['detections'], image,
         label_map=detector_label_map,
         classification_label_map=classification_label_map,
         confidence_threshold=confidence_threshold,
@@ -119,18 +127,20 @@ def _render_image(entry,
         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        
+    rendering_result['annotated_image_path'] = annotated_img_path
 
     return rendering_result
 
+# ...def _render_image(...)
+
 
 #%% Main function
 
 def visualize_detector_output(detector_output_path,
                               out_dir,
-                              images_dir,
+                              images_dir=None,
                               confidence_threshold=0.15,
                               sample=-1,
                               output_image_width=700,
@@ -145,36 +155,39 @@ def visualize_detector_output(detector_output_path,
                               parallelize_rendering_with_threads=True,
                               box_sort_order=None,
                               category_names_to_blur=None):
-    
     """
     Draws 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): folder where the images live; filenames in 
-            [detector_output_path] should be relative to [image_dir]
+        images_dir (str): folder where the images live; filenames in
+            [detector_output_path] should be relative to [image_dir].  Can be None if paths are
+            absolute.
         confidence_threshold (float, optional): threshold above which detections will be rendered
         sample (int, optional): maximum number of images to render, -1 for all
         output_image_width (int, optional): width in pixels to resize images for display,
             preserving aspect ration; set to -1 to use original image width
         random_seed (int, optional): seed to use for choosing images when sample != -1
-        render_detections_only (bool): only render images with above-threshold detections
+        render_detections_only (bool): only render images with above-threshold detections.  Empty
+            images are discarded after sampling, so if you want to see, e.g., 1000 non-empty images,
+            you can set [render_detections_only], but you need to sample more than 1000 images.
         classification_confidence_threshold (float, optional): only show classifications
             above this threshold; does not impact whether images are rendered, only whether
             classification labels (not detection categories) are displayed
         html_output_file (str, optional): output path for an HTML index file (not written
             if None)
-        html_output_options (dict, optional): HTML formatting options; see write_html_image_list 
-            for details
+        html_output_options (dict, optional): HTML formatting options; see write_html_image_list
+            for details.  The most common option you may want to supply here is
+            'maxFiguresPerHtmlFile'.
         preserve_path_structure (bool, optional): if False (default), writes images to unique
             names in a flat structure in the output folder; if True, preserves relative paths
             within the output folder
         parallelize_rendering (bool, optional): whether to use concurrent workers for rendering
-        parallelize_rendering_n_cores (int, optional): number of concurrent workers to use 
+        parallelize_rendering_n_cores (int, optional): number of concurrent workers to use
             (ignored if parallelize_rendering is False)
         parallelize_rendering_with_threads (bool, optional): determines whether we use
-            threads (True) or processes (False) for parallelization (ignored if parallelize_rendering 
+            threads (True) or processes (False) for parallelization (ignored if parallelize_rendering
             is False)
         box_sort_order (str, optional): sorting scheme for detection boxes, can be None, "confidence", or
             "reverse_confidence"
@@ -184,30 +197,29 @@ def visualize_detector_output(detector_output_path,
     Returns:
         list: list of paths to annotated images
     """
-    
+
     assert os.path.exists(detector_output_path), \
         'Detector output file does not exist at {}'.format(detector_output_path)
 
-    assert os.path.isdir(images_dir), \
-        'Image folder {} is not available'.format(images_dir)
+    if images_dir is not None:
+        assert os.path.isdir(images_dir), \
+            'Image folder {} is not available'.format(images_dir)
 
     os.makedirs(out_dir, exist_ok=True)
 
 
     ##%% Load detector output
 
-    with open(detector_output_path) as f:
-        detector_output = json.load(f)
-    assert 'images' in detector_output, (
-        'Detector output file should be a json with an "images" field.')
+    detector_output = load_md_or_speciesnet_file(detector_output_path)
+
     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).')
-    
+
+    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:
         detector_label_map = detector_output['detection_categories']
     else:
@@ -231,81 +243,91 @@ def visualize_detector_output(detector_output_path,
 
     print('Rendering detections above a confidence threshold of {}'.format(
         confidence_threshold))
-    
+
     classification_label_map = None
-    
+
     if 'classification_categories' in detector_output:
         classification_label_map = detector_output['classification_categories']
-        
+
     rendering_results = []
-    
+
     if parallelize_rendering:
-        
+
         if parallelize_rendering_with_threads:
             worker_string = 'threads'
         else:
             worker_string = 'processes'
-            
-        if parallelize_rendering_n_cores is None:
-            if parallelize_rendering_with_threads:
-                pool = ThreadPool()
-            else:
-                pool = Pool()
-        else:
-            if parallelize_rendering_with_threads:
-                pool = ThreadPool(parallelize_rendering_n_cores)
+
+        pool = None
+        try:
+            if parallelize_rendering_n_cores is None:
+                if parallelize_rendering_with_threads:
+                    pool = ThreadPool()
+                else:
+                    pool = Pool()
             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,
-                                         box_sort_order=box_sort_order,
-                                         category_names_to_blur=category_names_to_blur),
-                                 images), total=len(images)))
-        
+                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,
+                                             box_sort_order=box_sort_order,
+                                             category_names_to_blur=category_names_to_blur),
+                                     images), total=len(images)))
+        finally:
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print("Pool closed and joined for detector output visualization")
+
     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,box_sort_order,
                                             category_names_to_blur=category_names_to_blur)
             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 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:
-        
+
         html_dir = os.path.dirname(html_output_file)
-        
+
         html_image_info = []
-        
+
         for r in rendering_results:
             d = {}
+            if r['annotated_image_path'] is None:
+                assert r['failed_image'] or r['missing_image'] or r['skipped_image']
+                continue
             annotated_image_path_relative = os.path.relpath(r['annotated_image_path'],html_dir)
             d['filename'] = annotated_image_path_relative
             d['textStyle'] = \
@@ -313,17 +335,19 @@ def visualize_detector_output(detector_output_path,
                  '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_image_paths
 
+# ...def visualize_detector_output(...)
+
 
 #%% Command-line driver
 
-def main():
-    
+def main(): # noqa
+
     parser = argparse.ArgumentParser(
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
         description='Annotate the bounding boxes predicted by a detector above '
@@ -336,53 +360,56 @@ def main():
         help='Path to directory where the annotated images will be saved. '
              'The directory will be created if it does not exist.')
     parser.add_argument(
-        '-c', '--confidence', type=float, default=0.15,
+        '--confidence', type=float, default=0.15,
         help='Value between 0 and 1, indicating the confidence threshold '
              'above which to visualize bounding boxes')
     parser.add_argument(
-        '-i', '--images_dir', type=str, default=None,
+        '--images_dir', type=str, default=None,
         help='Path to a local directory where images are stored. This '
              'serves as the root directory for image paths in '
-             'detector_output_path.')
+             'detector_output_path.  Omit if image paths are absolute.')
     parser.add_argument(
-        '-n', '--sample', type=int, default=-1,
+        '--sample', type=int, default=-1,
         help='Number of images to be annotated and rendered. Set to -1 '
              '(default) to annotate all images in the detector output file. '
              'There may be fewer images if some are not found in images_dir.')
     parser.add_argument(
-        '-w', '--output_image_width', type=int, default=700,
+        '--output_image_width', type=int, default=700,
         help='Integer, desired width in pixels of the output annotated images. '
              'Use -1 to not resize. Default: 700.')
     parser.add_argument(
-        '-r', '--random_seed', type=int, default=None,
+        '--random_seed', type=int, default=None,
         help='Integer, for deterministic order of image sampling')
     parser.add_argument(
-        '-html', '--html_output_file', type=str, default=None,
+        '--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',
+        '--detections_only', action='store_true',
         help='Only render images with above-threshold detections (by default, '
              'both empty and non-empty images are rendered).')
     parser.add_argument(
-        '-pps', '--preserve_path_structure', action='store_true',
+        '--preserve_path_structure', action='store_true',
         help='Preserve relative image paths (otherwise flattens and assigns unique file names)')
     parser.add_argument(
         '--category_names_to_blur', default=None, type=str,
         help='Comma-separated list of category names to blur (or a single category name, typically "person")')
+    parser.add_argument(
+        '--classification_confidence', type=float, default=0.1,
+        help='If classification results are present, render results above this threshold')
 
     if len(sys.argv[1:]) == 0:
         parser.print_help()
         parser.exit()
 
     args = parser.parse_args()
-    
+
     category_names_to_blur = args.category_names_to_blur
     if category_names_to_blur is not None:
         category_names_to_blur = category_names_to_blur.split(',')
-    
+
     visualize_detector_output(
         detector_output_path=args.detector_output_path,
         out_dir=args.out_dir,
@@ -392,6 +419,7 @@ def main():
         output_image_width=args.output_image_width,
         random_seed=args.random_seed,
         render_detections_only=args.detections_only,
+        classification_confidence_threshold=args.classification_confidence,
         preserve_path_structure=args.preserve_path_structure,
         html_output_file=args.html_output_file,
         category_names_to_blur=category_names_to_blur)
@@ -407,12 +435,12 @@ if __name__ == '__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')
+
+    detector_output_path = os.path.expanduser('detections.json')
     out_dir = r'g:\temp\preview'
     images_dir = r'g:\camera_traps\camera_trap_images'
     confidence_threshold = 0.15
@@ -443,6 +471,6 @@ if False:
                               parallelize_rendering,
                               parallelize_rendering_n_cores,
                               parallelize_rendering_with_threads)
-    
+
     from megadetector.utils.path_utils import open_file
     open_file(html_output_file)

{megadetector-5.0.27.dist-info → megadetector-5.0.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: megadetector
-Version: 5.0.27
+Version: 5.0.29
 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>
@@ -34,7 +34,7 @@ Requires-Python: <3.14,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: mkl==2024.0; sys_platform != "darwin"
-Requires-Dist: numpy<2.0,>=1.26.4
+Requires-Dist: numpy>=1.26.4
 Requires-Dist: Pillow>=9.5
 Requires-Dist: tqdm>=4.64.0
 Requires-Dist: jsonpickle>=3.0.2
@@ -47,10 +47,13 @@ Requires-Dist: scikit-learn>=1.3.1
 Requires-Dist: pandas>=2.1.1
 Requires-Dist: python-dateutil
 Requires-Dist: send2trash
+Requires-Dist: python-dateutil
+Requires-Dist: clipboard
 Requires-Dist: dill
+Requires-Dist: ruff
+Requires-Dist: pytest
 Requires-Dist: ultralytics-yolov5==0.1.1
 Requires-Dist: yolov9pip==0.0.4
-Requires-Dist: python-dateutil
 Dynamic: license-file
 
 # MegaDetector