megadetector 5.0.15__py3-none-any.whl → 5.0.16__py3-none-any.whl

megadetector/postprocessing/subset_json_detector_output.py

@@ -124,7 +124,7 @@ class SubsetJsonDetectorOutputOptions:
         self.remove_failed_images = False
         
         #: Either a list of category IDs (as string-ints) (not names), or a dictionary mapping category *IDs* 
-        #: (as string-ints) (not names) to thresholds.  Removes  non-matching detections, does not 
+        #: (as string-ints) (not names) to thresholds.  Removes non-matching detections, does not 
         #: remove images.  Not technically mutually exclusize with category_names_to_keep, but it's an esoteric 
         #: scenario indeed where you would want to specify both.
         self.categories_to_keep = None
@@ -517,7 +517,7 @@ def subset_json_detector_output(input_filename, output_filename, options, data=N
     else:
         
         # Map images to unique folders
-        print('Finding unique folders')    
+        print('Finding unique folders')
         
         folders_to_images = {}
         
@@ -670,16 +670,26 @@ def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('input_file', type=str, help='Input .json filename')
     parser.add_argument('output_file', type=str, help='Output .json filename')
-    parser.add_argument('--query', type=str, default=None, help='Query string to search for (omitting this matches all)')
-    parser.add_argument('--replacement', type=str, default=None, help='Replace [query] with this')
-    parser.add_argument('--confidence_threshold', type=float, default=None, help='Remove detections below this confidence level')
-    parser.add_argument('--split_folders', action='store_true', help='Split .json files by leaf-node folder')
-    parser.add_argument('--split_folder_param', type=int, help='Directory level count for n_from_bottom and n_from_top splitting')
-    parser.add_argument('--split_folder_mode', type=str, help='Folder level to use for splitting ("top" or "bottom")')
-    parser.add_argument('--make_folder_relative', action='store_true', help='Make image paths relative to their containing folder (only meaningful with split_folders)')
-    parser.add_argument('--overwrite_json_files', action='store_true', help='Overwrite output files')
-    parser.add_argument('--copy_jsons_to_folders', action='store_true', help='When using split_folders and make_folder_relative, copy jsons to their corresponding folders (relative to output_file)')
-    parser.add_argument('--create_folders', action='store_true', help='When using copy_jsons_to_folders, create folders that don''t exist')    
+    parser.add_argument('--query', type=str, default=None, 
+                        help='Query string to search for (omitting this matches all)')
+    parser.add_argument('--replacement', type=str, default=None, 
+                        help='Replace [query] with this')
+    parser.add_argument('--confidence_threshold', type=float, default=None, 
+                        help='Remove detections below this confidence level')
+    parser.add_argument('--split_folders', action='store_true', 
+                        help='Split .json files by leaf-node folder')
+    parser.add_argument('--split_folder_param', type=int,
+                        help='Directory level count for n_from_bottom and n_from_top splitting')
+    parser.add_argument('--split_folder_mode', type=str,
+                        help='Folder level to use for splitting ("top" or "bottom")')
+    parser.add_argument('--make_folder_relative', action='store_true', 
+                        help='Make image paths relative to their containing folder (only meaningful with split_folders)')
+    parser.add_argument('--overwrite_json_files', action='store_true', 
+                        help='Overwrite output files')
+    parser.add_argument('--copy_jsons_to_folders', action='store_true', 
+                        help='When using split_folders and make_folder_relative, copy jsons to their corresponding folders (relative to output_file)')
+    parser.add_argument('--create_folders', action='store_true',
+                        help='When using copy_jsons_to_folders, create folders that don''t exist')    
     
     if len(sys.argv[1:]) == 0:
         parser.print_help()

megadetector/taxonomy_mapping/map_new_lila_datasets.py

@@ -15,10 +15,10 @@ import json
 # Created by get_lila_category_list.py
 input_lila_category_list_file = os.path.expanduser('~/lila/lila_categories_list/lila_dataset_to_categories.json')
 
-output_file = os.path.expanduser('~/lila/lila_additions_2023.12.29.csv')
+output_file = os.path.expanduser('~/lila/lila_additions_2024.07.16.csv')
 
 datasets_to_map = [
-    'Trail Camera Images of New Zealand Animals'
+    'Desert Lion Conservation Camera Traps'
     ]
 
 
@@ -133,7 +133,7 @@ if False:
     # q = 'white-throated monkey'
     # q = 'cingulata'
     # q = 'notamacropus'
-    q = 'porzana'
+    q = 'aves'
     taxonomy_preference = 'inat'
     m = get_preferred_taxonomic_match(q,taxonomy_preference)
     # print(m.scientific_name); import clipboard; clipboard.copy(m.scientific_name)

megadetector/taxonomy_mapping/prepare_lila_taxonomy_release.py

@@ -24,7 +24,7 @@ if False:
     release_taxonomy_file = os.path.expanduser('~/lila/lila-taxonomy-mapping_release.csv')
     # import clipboard; clipboard.copy(release_taxonomy_file)
 
-    # Created by get_lila_category_list.py... contains counts for each category
+    # Created by get_lila_annotation_counts.py... contains counts for each category
     lila_dataset_to_categories_file = os.path.expanduser('~/lila/lila_categories_list/lila_dataset_to_categories.json')
 
     assert os.path.isfile(lila_dataset_to_categories_file)
@@ -140,3 +140,4 @@ if False:
 
     print('Wrote final output to {}'.format(release_taxonomy_file))
 
+# ...if False

megadetector/taxonomy_mapping/preview_lila_taxonomy.py

@@ -16,7 +16,7 @@ import os
 import pandas as pd
 
 # lila_taxonomy_file = r"c:\git\agentmorrisprivate\lila-taxonomy\lila-taxonomy-mapping.csv"
-lila_taxonomy_file = os.path.expanduser('~/lila/lila_additions_2023.12.29.csv')
+lila_taxonomy_file = os.path.expanduser('~/lila/lila_additions_2024.07.16.csv')
 
 preview_base = os.path.expanduser('~/lila/lila_taxonomy_preview')
 os.makedirs(preview_base,exist_ok=True)

megadetector/taxonomy_mapping/simple_image_download.py

@@ -8,6 +8,11 @@ Slightly modified from:
 
 https://github.com/RiddlerQ/simple_image_download
 
+pip install python-magic
+
+# On Windows, also run:
+pip install python-magic-bin
+
 """
 
 #%% Imports

megadetector/taxonomy_mapping/species_lookup.py

@@ -208,7 +208,7 @@ def initialize_taxonomy_lookup(force_init=False) -> None:
     # Load GBIF taxonomy
     gbif_taxonomy_file = os.path.join(taxonomy_download_dir, 'GBIF', 'Taxon.tsv')
     print('Loading GBIF taxonomy from {}'.format(gbif_taxonomy_file))
-    gbif_taxonomy = pd.read_csv(gbif_taxonomy_file, sep='\t')
+    gbif_taxonomy = pd.read_csv(gbif_taxonomy_file, sep='\t', encoding='utf-8',on_bad_lines='warn')
     gbif_taxonomy['scientificName'] = gbif_taxonomy['scientificName'].fillna('').str.strip()
     gbif_taxonomy['canonicalName'] = gbif_taxonomy['canonicalName'].fillna('').str.strip()
 

megadetector/utils/md_tests.py

@@ -29,6 +29,10 @@ import subprocess
 import argparse
 import inspect
 
+#: IoU threshold used to determine whether boxes in two detection files likely correspond
+#: to the same box.
+iou_threshold_for_file_comparison = 0.9
+
 
 #%% Classes
 
@@ -359,6 +363,100 @@ def output_files_are_identical(fn1,fn2,verbose=False):
 # ...def output_files_are_identical(...)
    
 
+def compare_detection_lists(detections_a,detections_b,options,bidirectional_comparison=True):
+    """
+    Compare two lists of MD-formatted detections, matching detections across lists using IoU
+    criteria.  Generally used to compare detections for the same image when two sets of results 
+    are expected to be more or less the same.
+    
+    Args:
+        detections_a (list): the first set of detection dicts
+        detections_b (list): the second set of detection dicts
+        options (MDTestOptions): options that determine tolerable differences between files    
+        bidirectional_comparison (bool, optional): reverse the arguments and make a recursive
+            call.
+            
+    Returns:
+        dict: a dictionary with keys 'max_conf_error' and 'max_coord_error'.
+    """
+    from megadetector.utils.ct_utils import get_iou
+    
+    max_conf_error = 0
+    max_coord_error = 0
+        
+    # i_det_a = 0
+    for i_det_a in range(0,len(detections_a)):
+        
+        det_a = detections_a[i_det_a]
+        
+        # Don't process very-low-confidence boxes
+        if det_a['conf'] < options.max_conf_error:
+            continue
+        
+        matching_det_b = None
+        highest_iou = -1
+        
+        # Find the closest match in the detections_b list
+        
+        # i_det_b = 0
+        for i_det_b in range(0,len(detections_b)):
+            
+            b_det = detections_b[i_det_b]
+            
+            if b_det['category'] != det_a['category']:
+                continue
+            
+            iou = get_iou(det_a['bbox'],b_det['bbox'])
+            
+            # Is this likely the same detection as det_a?
+            if iou >= iou_threshold_for_file_comparison and iou > highest_iou:
+                matching_det_b = b_det
+                highest_iou = iou
+                
+        # If there are no detections in this category in detections_b
+        if matching_det_b is None:
+            if det_a['conf'] > max_conf_error:
+                max_conf_error = det_a['conf']
+            # max_coord_error = 1.0
+            continue
+        
+        assert det_a['category'] == matching_det_b['category']
+        conf_err = abs(det_a['conf'] - matching_det_b['conf'])
+        coord_differences = []
+        for i_coord in range(0,4):
+            coord_differences.append(abs(det_a['bbox'][i_coord]-\
+                                         matching_det_b['bbox'][i_coord]))
+        coord_err = max(coord_differences)
+        
+        if conf_err >= max_conf_error:
+            max_conf_error = conf_err
+            
+        if coord_err >= max_coord_error:
+            max_coord_error = coord_err            
+    
+    # ...for each detection in detections_a
+    
+    if bidirectional_comparison:
+        
+        reverse_comparison_results = compare_detection_lists(detections_b,
+                                                             detections_a, 
+                                                             options, 
+                                                             bidirectional_comparison=False)
+        
+        if reverse_comparison_results['max_conf_error'] > max_conf_error:
+            max_conf_error = reverse_comparison_results['max_conf_error']
+        if reverse_comparison_results['max_coord_error'] > max_coord_error:
+            max_coord_error = reverse_comparison_results['max_coord_error']
+    
+    list_comparison_results = {}
+    list_comparison_results['max_coord_error'] = max_coord_error
+    list_comparison_results['max_conf_error'] = max_conf_error
+    
+    return list_comparison_results
+
+# ...def compare_detection_lists(...)
+
+
 def compare_results(inference_output_file,expected_results_file,options):
     """
     Compare two MD-formatted output files that should be nearly identical, allowing small
@@ -369,6 +467,9 @@ def compare_results(inference_output_file,expected_results_file,options):
         inference_output_file (str): the first results file to compare
         expected_results_file (str): the second results file to compare
         options (MDTestOptions): options that determine tolerable differences between files
+        
+    Returns:
+        dict: dictionary with keys 'max_coord_error' and 'max_conf_error'
     """
     
     # Read results
@@ -386,8 +487,11 @@ def compare_results(inference_output_file,expected_results_file,options):
             len(filename_to_results_expected),
             len(filename_to_results))
     
-    max_coord_error = 0
     max_conf_error = 0
+    max_conf_error_file = None
+    
+    max_coord_error = 0
+    max_coord_error_file = None    
     
     # fn = next(iter(filename_to_results.keys()))
     for fn in filename_to_results.keys():
@@ -405,36 +509,20 @@ def compare_results(inference_output_file,expected_results_file,options):
         actual_detections = actual_image_results['detections']
         expected_detections = expected_image_results['detections']
         
-        s = 'expected {} detections for file {}, found {}'.format(
-            len(expected_detections),fn,len(actual_detections))
-        s += '\nExpected results file: {}\nActual results file: {}'.format(
-            expected_results_file,inference_output_file)
+        comparison_results_this_image = compare_detection_lists(
+            detections_a=actual_detections,
+            detections_b=expected_detections,
+            options=options,
+            bidirectional_comparison=True)
         
-        if options.warning_mode:
-            if len(actual_detections) != len(expected_detections):
-                print('Warning: {}'.format(s))
-            continue
-        assert len(actual_detections) == len(expected_detections), \
-            'Error: {}'.format(s)
-        
-        # i_det = 0
-        for i_det in range(0,len(actual_detections)):
-            actual_det = actual_detections[i_det]
-            expected_det = expected_detections[i_det]
-            assert actual_det['category'] == expected_det['category']
-            conf_err = abs(actual_det['conf'] - expected_det['conf'])
-            coord_differences = []
-            for i_coord in range(0,4):
-                coord_differences.append(abs(actual_det['bbox'][i_coord]-expected_det['bbox'][i_coord]))
-            coord_err = max(coord_differences)
+        if comparison_results_this_image['max_conf_error'] > max_conf_error:
+            max_conf_error = comparison_results_this_image['max_conf_error']
+            max_conf_error_file = fn
             
-            if conf_err > max_conf_error:
-                max_conf_error = conf_err
-            if coord_err > max_coord_error:
-                max_coord_error = coord_err
-        
-        # ...for each detection
-        
+        if comparison_results_this_image['max_coord_error'] > max_coord_error:
+            max_coord_error = comparison_results_this_image['max_coord_error']
+            max_coord_error_file = fn
+                
     # ...for each image
     
     if not options.warning_mode:
@@ -447,9 +535,17 @@ def compare_results(inference_output_file,expected_results_file,options):
             'Coord error {} is greater than allowable ({})'.format(
                 max_coord_error,options.max_coord_error)
         
-    print('Max conf error: {}'.format(max_conf_error))
-    print('Max coord error: {}'.format(max_coord_error))
+    print('Max conf error: {} (file {})'.format(
+        max_conf_error,max_conf_error_file))
+    print('Max coord error: {} (file {})'.format(
+        max_coord_error,max_coord_error_file))
     
+    comparison_results = {}
+    comparison_results['max_conf_error'] = max_conf_error
+    comparison_results['max_coord_error'] = max_coord_error
+
+    return comparison_results
+
 # ...def compare_results(...)
 
 
@@ -557,6 +653,8 @@ def run_python_tests(options):
     
     ## Run inference on an image
     
+    print('\n** Running MD on a single image **\n')
+    
     from megadetector.detection import run_detector
     from megadetector.visualization import visualization_utils as vis_utils
     image_fn = os.path.join(options.scratch_dir,options.test_images[0])
@@ -567,7 +665,7 @@ def run_python_tests(options):
     
     ## Run inference on a folder
 
-    print('\n** Running MD on images **\n')
+    print('\n** Running MD on a folder of images **\n')
     
     from megadetector.detection.run_detector_batch import load_and_run_detector_batch,write_results_to_file
     from megadetector.utils import path_utils
@@ -584,12 +682,15 @@ def run_python_tests(options):
 
     
     ## Verify results
-
+    
     expected_results_file = get_expected_results_filename(is_gpu_available(verbose=False),
                                                           options=options)
     compare_results(inference_output_file,expected_results_file,options)
         
-
+    # Make note of this filename, we will use it again later
+    inference_output_file_standard_inference = inference_output_file
+    
+    
     ## Run and verify again with augmentation enabled
     
     print('\n** Running MD on images with augmentation **\n')
@@ -651,6 +752,7 @@ def run_python_tests(options):
             
         from megadetector.detection.run_inference_with_yolov5_val import \
             YoloInferenceOptions, run_inference_with_yolo_val
+        from megadetector.utils.path_utils import insert_before_extension
         
         inference_output_file_yolo_val = os.path.join(options.scratch_dir,'folder_inference_output_yolo_val.json')
         
@@ -661,12 +763,23 @@ def run_python_tests(options):
         yolo_inference_options.model_filename = options.default_model
         yolo_inference_options.augment = False
         yolo_inference_options.overwrite_handling = 'overwrite'
+        from megadetector.detection.run_detector import DEFAULT_OUTPUT_CONFIDENCE_THRESHOLD
+        yolo_inference_options.conf_thres = DEFAULT_OUTPUT_CONFIDENCE_THRESHOLD
         
         run_inference_with_yolo_val(yolo_inference_options)
         
+        ## Confirm this matches the standard inference path
+        
+        if False:
+            # TODO: compare_results() isn't quite ready for this yet
+            compare_results(inference_output_file=inference_output_file_yolo_val, 
+                            expected_results_file=inference_output_file_standard_inference, 
+                            options=options)
+        
+        
+        
         # Run again, without symlinks this time
         
-        from megadetector.utils.path_utils import insert_before_extension
         inference_output_file_yolo_val_no_links = insert_before_extension(inference_output_file_yolo_val,
                                                                           'no-links')
         yolo_inference_options.output_file = inference_output_file_yolo_val_no_links
@@ -712,6 +825,7 @@ def run_python_tests(options):
         print('\n** Running MD on a single video **\n')
         
         from megadetector.detection.process_video import ProcessVideoOptions, process_video
+        from megadetector.utils.path_utils import insert_before_extension
         
         video_options = ProcessVideoOptions()
         video_options.model_file = options.default_model
@@ -750,22 +864,23 @@ def run_python_tests(options):
         print('\n** Running MD on a folder of videos **\n')
         
         from megadetector.detection.process_video import ProcessVideoOptions, process_video_folder
+        from megadetector.utils.path_utils import insert_before_extension
         
         video_options = ProcessVideoOptions()
         video_options.model_file = options.default_model
         video_options.input_video_file = os.path.join(options.scratch_dir,
                                                       os.path.dirname(options.test_videos[0]))
         video_options.output_json_file = os.path.join(options.scratch_dir,'video_folder_output.json')
-        # video_options.output_video_file = None
+        video_options.output_video_file = None
         video_options.frame_folder = os.path.join(options.scratch_dir,'video_scratch/frame_folder')
         video_options.frame_rendering_folder = os.path.join(options.scratch_dir,'video_scratch/rendered_frame_folder')    
         video_options.render_output_video = False
-        # video_options.keep_rendered_frames = False
-        # video_options.keep_rendered_frames = False
+        video_options.keep_rendered_frames = False
+        video_options.keep_rendered_frames = False
         video_options.force_extracted_frame_folder_deletion = True
         video_options.force_rendered_frame_folder_deletion = True
-        # video_options.reuse_results_if_available = False
-        # video_options.reuse_frames_if_available = False
+        video_options.reuse_results_if_available = False
+        video_options.reuse_frames_if_available = False
         video_options.recursive = True
         video_options.verbose = True
         video_options.fourcc = options.video_fourcc
@@ -773,12 +888,16 @@ def run_python_tests(options):
         # video_options.json_confidence_threshold = 0.005
         video_options.frame_sample = 10  
         video_options.n_cores = 5        
+        
+        # Force frame extraction to disk, since that's how we generated our expected results file
+        video_options.force_on_disk_frame_extraction = True
         # video_options.debug_max_frames = -1
         # video_options.class_mapping_filename = None
         
         # Use quality == None, because we can't control whether YOLOv5 has patched cm2.imread,
         # and therefore can't rely on using the quality parameter
-        video_options.quality = None        
+        video_options.quality = None
+        video_options.max_width = None
         
         _ = process_video_folder(video_options)
     
@@ -796,6 +915,29 @@ def run_python_tests(options):
         assert os.path.isfile(expected_results_file)
         compare_results(frame_output_file,expected_results_file,options)
         
+        
+        ## Run again, this time in memory, and make sure the results are *almost* the same
+        
+        # They won't be quite the same, because the on-disk path goes through a jpeg intermediate
+        
+        print('\n** Running MD on a folder of videos (in memory) **\n')
+        
+        video_options.output_json_file = insert_before_extension(video_options.output_json_file,'in-memory')
+        video_options.force_on_disk_frame_extraction = False
+        _ = process_video_folder(video_options)
+                
+        frame_output_file_in_memory = insert_before_extension(video_options.output_json_file,'frames')
+        assert os.path.isfile(frame_output_file_in_memory)
+        
+        from copy import deepcopy
+        options_loose = deepcopy(options)
+        options_loose.max_conf_error = 0.05
+        options_loose.max_coord_error = 0.01
+        
+        compare_results(inference_output_file=frame_output_file,
+                        expected_results_file=frame_output_file_in_memory,
+                        options=options_loose)
+                
     # ...if we're not skipping video tests
     
     print('\n*** Finished module tests ***\n')
@@ -885,7 +1027,8 @@ def run_cli_tests(options):
     cmd_results = execute_and_print(cmd)
     
     assert output_files_are_identical(fn1=inference_output_file, 
-                                      fn2=inference_output_file_checkpoint,verbose=True)
+                                      fn2=inference_output_file_checkpoint,
+                                      verbose=True)
     
     
     ## Run again with the image queue enabled, make sure the results are the same
@@ -897,7 +1040,8 @@ def run_cli_tests(options):
     cmd_results = execute_and_print(cmd)
     
     assert output_files_are_identical(fn1=inference_output_file, 
-                                      fn2=inference_output_file_queue,verbose=True)
+                                      fn2=inference_output_file_queue,
+                                      verbose=True)
     
     
     ## Run again on multiple cores, make sure the results are the same
@@ -935,7 +1079,8 @@ def run_cli_tests(options):
         del os.environ['CUDA_VISIBLE_DEVICES']
         
     assert output_files_are_identical(fn1=inference_output_file_cpu, 
-                                      fn2=inference_output_file_cpu_multicore,verbose=True)
+                                      fn2=inference_output_file_cpu_multicore,
+                                      verbose=True)
     
     
     ## Postprocessing
@@ -1041,7 +1186,8 @@ def run_cli_tests(options):
         cmd_results = execute_and_print(cmd)
         
         assert output_files_are_identical(fn1=inference_output_file_yolo_val,
-                                          fn2=inference_output_file_yolo_val_checkpoint)
+                                          fn2=inference_output_file_yolo_val_checkpoint,
+                                          verbose=True)
         
     if not options.skip_video_tests:
             
@@ -1161,19 +1307,21 @@ if False:
     options.cpu_execution_is_error = False
     options.skip_video_tests = False
     options.skip_python_tests = False
-    options.skip_cli_tests = False
+    options.skip_cli_tests = True
     options.scratch_dir = None
     options.test_data_url = 'https://lila.science/public/md-test-package.zip'
     options.force_data_download = False
     options.force_data_unzip = False
-    options.warning_mode = True
+    options.warning_mode = False
     options.max_coord_error = 0.001
     options.max_conf_error = 0.005
     options.cli_working_dir = r'c:\git\MegaDetector'
     options.yolo_working_dir = r'c:\git\yolov5-md'
 
-    import os
     
+    #%%
+    
+    import os
     if 'PYTHONPATH' not in os.environ or options.yolo_working_dir not in os.environ['PYTHONPATH']:
         os.environ['PYTHONPATH'] += ';' + options.yolo_working_dir
 
@@ -1332,4 +1480,3 @@ if False:
     fn1 = r"G:\temp\md-test-package\mdv5a-image-cpu-pt1.10.1.json"
     fn2 = r"G:\temp\md-test-package\mdv5a-augment-image-cpu-pt1.10.1.json"
     print(output_files_are_identical(fn1,fn2,verbose=True))
-    

megadetector/utils/path_utils.py

@@ -924,8 +924,8 @@ def zip_files_into_single_zipfile(input_files, output_fn, arc_name_base,
     
 def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, compresslevel=9):
     """
-    Recursively zip everything in [input_folder] into a single zipfile, storing outputs as relative 
-    paths.
+    Recursively zip everything in [input_folder] into a single zipfile, storing files as paths 
+    relative to [input_folder].
     
     Args: 
         input_folder (str): folder to zip

megadetector/utils/url_utils.py

@@ -75,7 +75,8 @@ def download_url(url,
                  destination_filename=None, 
                  progress_updater=None, 
                  force_download=False, 
-                 verbose=True):
+                 verbose=True,
+                 escape_spaces=True):
     """
     Downloads a URL to a file.  If no file is specified, creates a temporary file, 
     making a best effort to avoid filename collisions.
@@ -92,6 +93,7 @@ def download_url(url,
         force_download (bool, optional): download this file even if [destination_filename]
             exists.
         verbose (bool, optional): enable additional debug console output
+        escape_spaces (bool, optional): replace ' ' with '%20'
         
     Returns:
         str: the filename to which [url] was downloaded, the same as [destination_filename]
@@ -107,6 +109,7 @@ def download_url(url,
     url_no_sas = url.split('?')[0]
         
     if destination_filename is None:
+        
         target_folder = get_temp_folder()
         url_without_sas = url.split('?', 1)[0]
         
@@ -119,6 +122,9 @@ def download_url(url,
         destination_filename = \
             os.path.join(target_folder,url_as_filename)
         
+    if escape_spaces:
+        url = url.replace(' ','%20')
+        
     if (not force_download) and (os.path.isfile(destination_filename)):
         if verbose:
             print('Bypassing download of already-downloaded file {}'.format(os.path.basename(url_no_sas)))

megadetector/visualization/visualize_db.py

@@ -122,6 +122,14 @@ class DbVizOptions:
         
         #: Enable additionald debug console output
         self.verbose = False
+        
+        #: COCO files used for evaluation may contain confidence scores, this
+        #: determines the field name used for confidence scores
+        self.confidence_field_name = 'score'
+        
+        #: Optionally apply a confidence threshold; this requires that [confidence_field_name] 
+        #: be present in all detections.
+        self.confidence_threshold = None
     
 
 #%% Helper functions
@@ -294,6 +302,14 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         # iAnn = 0; anno = annos_i.iloc[iAnn]
         for iAnn,anno in annos_i.iterrows():
         
+            if options.confidence_threshold is not None:
+                assert options.confidence_field_name in anno, \
+                    'Error: confidence thresholding requested, ' + \
+                        'but at least one annotation does not have the {} field'.format(
+                            options.confidence_field_name)
+                if anno[options.confidence_field_name] < options.confidence_threshold:
+                    continue
+                
             if 'sequence_level_annotation' in anno:
                 bSequenceLevelAnnotation = anno['sequence_level_annotation']
                 if bSequenceLevelAnnotation:

{megadetector-5.0.15.dist-info → megadetector-5.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: megadetector
-Version: 5.0.15
+Version: 5.0.16
 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>
@@ -54,7 +54,7 @@ Requires-Dist: ultralytics-yolov5 ==0.1.1
 
 This package is a pip-installable version of the support/inference code for [MegaDetector](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector), an object detection model that helps conservation biologists spend less time doing boring things with camera trap images.  Complete documentation for this Python package is available at [megadetector.readthedocs.io](https://megadetector.readthedocs.io).
 
-If you aren't looking for the Python package specificaly, and you just want to learn more about what MegaDetector is all about, head over to the [MegaDetector repo](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector).
+If you aren't looking for the Python package specifically, and you just want to learn more about what MegaDetector is all about, head over to the [MegaDetector repo](https://github.com/agentmorris/MegaDetector/?tab=readme-ov-file#megadetector).
 
 
 ## Reasons you probably aren't looking for this package