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

detection/run_inference_with_yolov5_val.py

@@ -49,6 +49,7 @@ from tqdm import tqdm
 
 from md_utils import path_utils
 from md_utils import process_utils
+from md_utils import string_utils
 from data_management import yolo_output_to_md_output
 from detection.run_detector import try_download_known_detector
 
@@ -68,17 +69,20 @@ class YoloInferenceOptions:
     
     ## Optional ##
     
-    # Required for YOLOv5 models, not for YOLOv8 models
+    # Required for older YOLOv5 inference, not for newer ulytralytics inference
     yolo_working_folder = None
     
-    model_type = 'yolov5' # currently 'yolov5' and 'yolov8' are supported
+    # Currently 'yolov5' and 'ultralytics' are supported, and really these are proxies for
+    # "the yolov5 repo" and "the ultralytics repo" (typically YOLOv8).
+    model_type = 'yolov5' 
 
     image_size = default_image_size_with_augmentation
     conf_thres = '0.001'
     batch_size = 1
     device_string = '0'
     augment = True
-
+    half_precision_enabled = None
+    
     symlink_folder = None
     use_symlinks = True
     
@@ -97,16 +101,28 @@ class YoloInferenceOptions:
     overwrite_handling = 'skip'
     
     preview_yolo_command_only = False
+    
+    treat_copy_failures_as_warnings = False
+    
+    save_yolo_debug_output = False
             
     
 #%% Main function
 
 def run_inference_with_yolo_val(options):
 
-    ##%% Path handling
+    ##%% Input and path handling
+    
+    if options.model_type == 'yolov8':
+        
+        print('Warning: model type "yolov8" supplied, "ultralytics" is the preferred model type string for YOLOv8 models')
+        options.model_type = 'ultralytics'
+        
+    if (options.model_type == 'yolov5') and ('yolov8' in options.model_filename.lower()):
+        print('\n\n*** Warning: model type set as "yolov5", but your model filename contains "yolov8"... did you mean to use --model_type yolov8?" ***\n\n')        
     
     if options.yolo_working_folder is None:
-        assert options.model_type == 'yolov8', \
+        assert options.model_type == 'ultralytics', \
             'A working folder is required to run YOLOv5 val.py'
     else:
         assert os.path.isdir(options.yolo_working_folder), \
@@ -115,6 +131,11 @@ def run_inference_with_yolo_val(options):
     assert os.path.isdir(options.input_folder) or os.path.isfile(options.input_folder), \
         'Could not find input {}'.format(options.input_folder)
     
+    if options.half_precision_enabled is not None:
+        assert options.half_precision_enabled in (0,1), \
+            'Invalid value {} for --half_precision_enabled (should be 0 or 1)'.format(
+                options.half_precision_enabled)
+            
     # If the model filename is a known model string (e.g. "MDv5A", download the model if necessary)
     model_filename = try_download_known_detector(options.model_filename)
     
@@ -218,10 +239,20 @@ def run_inference_with_yolo_val(options):
             else:
                 shutil.copyfile(image_fn,symlink_full_path)
         except Exception as e:
-            image_id_to_error[image_id] = str(e)
-            print('Warning: error copying/creating link for input file {}: {}'.format(
-                image_fn,str(e)))
-            continue
+            error_string = str(e)
+            image_id_to_error[image_id] = error_string
+            # Always break if the user is trying to create symlinks on Windows without
+            # permission, 100% of images will always fail in this case.
+            if ('a required privilege is not held by the client' in error_string.lower()) or \
+               (not options.treat_copy_failures_as_warnings):
+                   print('\nError copying/creating link for input file {}: {}'.format(
+                       image_fn,error_string))
+                   
+                   raise
+            else:
+                print('Warning: error copying/creating link for input file {}: {}'.format(
+                    image_fn,error_string))
+                continue
         
     # ...for each image
 
@@ -270,17 +301,34 @@ def run_inference_with_yolo_val(options):
         if options.augment:
             cmd += ' --augment'
                 
-    elif options.model_type == 'yolov8':
+        # --half is a store_true argument for YOLOv5's val.py
+        if (options.half_precision_enabled is not None) and (options.half_precision_enabled == 1):
+            cmd += ' --half'
+        
+        # Sometimes useful for debugging
+        # cmd += ' --save_conf --save_txt'
         
+    elif options.model_type == 'ultralytics':
+                
         if options.augment:
             augment_string = 'augment'
         else:
             augment_string = ''
             
-        cmd = 'yolo val {} model="{}" imgsz={} batch={} data="{}" project="{}" name="{}"'.format(
-            augment_string,model_filename,image_size_string,options.batch_size,yolo_dataset_file,
-            yolo_results_folder,'yolo_results')        
-        cmd += ' save_hybrid save_json'        
+        cmd = 'yolo val {} model="{}" imgsz={} batch={} data="{}" project="{}" name="{}" device="{}"'.\
+            format(augment_string,model_filename,image_size_string,options.batch_size,
+                   yolo_dataset_file,yolo_results_folder,'yolo_results',options.device_string)
+        cmd += ' save_json exist_ok'
+        
+        if (options.half_precision_enabled is not None):
+            if options.half_precision_enabled == 1:
+                cmd += ' --half=True'
+            else:
+                assert options.half_precision_enabled == 0
+                cmd += ' --half=False'
+        
+        # Sometimes useful for debugging
+        # cmd += ' save_conf save_txt'
             
     else:
         
@@ -293,38 +341,84 @@ def run_inference_with_yolo_val(options):
     
     if options.yolo_working_folder is not None:
         current_dir = os.getcwd()
-        os.chdir(options.yolo_working_folder)    
+        os.chdir(options.yolo_working_folder)
+
     print('Running YOLO inference command:\n{}\n'.format(cmd))
     
     if options.preview_yolo_command_only:
+        
         if options.remove_symlink_folder:
             try:
+                print('Removing YOLO symlink folder {}'.format(symlink_folder))
                 shutil.rmtree(symlink_folder)
             except Exception:
                 print('Warning: error removing symlink folder {}'.format(symlink_folder))
                 pass
         if options.remove_yolo_results_folder:
             try:
+                print('Removing YOLO results folder {}'.format(yolo_results_folder))
                 shutil.rmtree(yolo_results_folder)
             except Exception:
                 print('Warning: error removing YOLO results folder {}'.format(yolo_results_folder))
                 pass
         
         sys.exit()
-        
-    execution_result = process_utils.execute_and_print(cmd)
+    
+    execution_result = process_utils.execute_and_print(cmd,encoding='utf-8',verbose=True)
     assert execution_result['status'] == 0, 'Error running {}'.format(options.model_type)
     yolo_console_output = execution_result['output']
+      
+    if options.save_yolo_debug_output:
+        with open(os.path.join(yolo_results_folder,'yolo_console_output.txt'),'w') as f:
+            for s in yolo_console_output:
+                f.write(s + '\n')
+        with open(os.path.join(yolo_results_folder,'image_id_to_file.json'),'w') as f:
+            json.dump(image_id_to_file,f,indent=1)
+        with open(os.path.join(yolo_results_folder,'image_id_to_error.json'),'w') as f:
+            json.dump(image_id_to_error,f,indent=1)
+                
+        
+    # YOLO console output contains lots of ANSI escape codes, remove them for easier parsing
+    yolo_console_output = [string_utils.remove_ansi_codes(s) for s in yolo_console_output]
     
+    # Find errors that occrred during the initial corruption check; these will not be included in the
+    # output.  Errors that occur during inference will be handled separately.
     yolo_read_failures = []
+    
     for line in yolo_console_output:
+        # Lines look like:
+        #
+        # For ultralytics val:
+        #
+        # val: WARNING ⚠️ /a/b/c/d.jpg: ignoring corrupt image/label: [Errno 13] Permission denied: '/a/b/c/d.jpg'
+        # line = "val: WARNING ⚠️ /a/b/c/d.jpg: ignoring corrupt image/label: [Errno 13] Permission denied: '/a/b/c/d.jpg'"
+        #
+        # For yolov5 val.py:
+        #
+        # test: WARNING: a/b/c/d.jpg: ignoring corrupt image/label: cannot identify image file '/a/b/c/d.jpg'
+        # line = "test: WARNING: a/b/c/d.jpg: ignoring corrupt image/label: cannot identify image file '/a/b/c/d.jpg'"
         if 'cannot identify image file' in line:
             tokens = line.split('cannot identify image file')
             image_name = tokens[-1].strip()
             assert image_name[0] == "'" and image_name [-1] == "'"
             image_name = image_name[1:-1]
             yolo_read_failures.append(image_name)            
-            
+        elif 'ignoring corrupt image/label' in line:
+            assert 'WARNING' in line
+            if '⚠️' in line:
+                assert line.startswith('val'), \
+                    'Unrecognized line in YOLO output: {}'.format(line)
+                tokens = line.split('ignoring corrupt image/label')
+                image_name = tokens[0].split('⚠️')[-1].strip()
+            else:
+                assert line.startswith('test'), \
+                    'Unrecognized line in YOLO output: {}'.format(line)
+                tokens = line.split('ignoring corrupt image/label')
+                image_name = tokens[0].split('WARNING:')[-1].strip()
+            assert image_name.endswith(':')
+            image_name = image_name[0:-1]
+            yolo_read_failures.append(image_name)
+                    
     # image_file = yolo_read_failures[0]
     for image_file in yolo_read_failures:
         image_id = os.path.splitext(os.path.basename(image_file))[0]
@@ -338,7 +432,7 @@ def run_inference_with_yolo_val(options):
     
     ##%% Convert results to MD format
     
-    json_files = glob.glob(yolo_results_folder+ '/yolo_results/*.json')
+    json_files = glob.glob(yolo_results_folder + '/yolo_results/*.json')
     assert len(json_files) == 1    
     yolo_json_file = json_files[0]
 
@@ -390,7 +484,7 @@ def run_inference_with_yolo_val(options):
 
 #%% Command-line driver
 
-import argparse,sys
+import argparse
 from md_utils.ct_utils import args_to_object
 
 def main():
@@ -422,9 +516,12 @@ def main():
     parser.add_argument(
         '--batch_size', default=options.batch_size, type=int,
         help='inference batch size (default {})'.format(options.batch_size))
+    parser.add_argument(
+        '--half_precision_enabled', default=None, type=int,
+        help='use half-precision-inference (1 or 0) (default is the underlying model\'s default, probably half for YOLOv8 and full for YOLOv8')
     parser.add_argument(
         '--device_string', default=options.device_string, type=str,
-        help='CUDA device specifier, e.g. "0" or "cpu" (default {})'.format(options.device_string))
+        help='CUDA device specifier, typically "0" or "1" for CUDA devices, "mps" for M1/M2 devices, or "cpu" (default {})'.format(options.device_string))
     parser.add_argument(
         '--overwrite_handling', default=options.overwrite_handling, type=str,
         help='action to take if the output file exists (skip, error, overwrite) (default {})'.format(
@@ -435,7 +532,7 @@ def main():
             '(otherwise defaults to MD categories)')
     parser.add_argument(
         '--model_type', default=options.model_type, type=str,
-        help='Model type (yolov5 or yolov8) (default {})'.format(options.model_type))
+        help='Model type ("yolov5" or "ultralytics" ("yolov8" behaves the same as "ultralytics")) (default {})'.format(options.model_type))
 
     parser.add_argument(
         '--symlink_folder', type=str,
@@ -452,6 +549,9 @@ def main():
     parser.add_argument(
         '--no_remove_yolo_results_folder', action='store_true',
         help='don\'t remove the temporary folder full of YOLO intermediate files')
+    parser.add_argument(
+        '--save_yolo_debug_output', action='store_true',
+        help='write yolo console output to a text file in the results folder, along with additional debug files')
     
     parser.add_argument(
         '--preview_yolo_command_only', action='store_true',
@@ -474,14 +574,15 @@ def main():
         
     # If the caller hasn't specified an image size, choose one based on whether augmentation
     # is enabled.
-    if args.image_size is None:
-        assert options.augment in (0,1)
-        if options.augment == 1:
+    if args.image_size is None:        
+        assert args.augment_enabled in (0,1), \
+            'Illegal augment_enabled value {}'.format(args.augment_enabled)
+        if args.augment_enabled == 1:
             args.image_size = default_image_size_with_augmentation
         else:
             args.image_size = default_image_size_with_no_augmentation
         augment_enabled_string = 'enabled'
-        if not options.augment:
+        if not args.augment_enabled:
             augment_enabled_string = 'disabled'
         print('Augmentation is {}, using default image size {}'.format(
             augment_enabled_string,args.image_size))

detection/run_tiled_inference.py

@@ -29,6 +29,7 @@ from tqdm import tqdm
 
 from detection.run_inference_with_yolov5_val import YoloInferenceOptions,run_inference_with_yolo_val
 from detection.run_detector_batch import load_and_run_detector_batch,write_results_to_file
+from detection.run_detector import try_download_known_detector
 
 import torch
 from torchvision import ops
@@ -234,7 +235,7 @@ def in_place_nms(md_results, iou_thres=0.45, verbose=True):
     # i_image = 18; im = md_results['images'][i_image]
     for i_image,im in tqdm(enumerate(md_results['images']),total=len(md_results['images'])):
         
-        if len(im['detections']) == 0:
+        if (im['detections'] is None) or (len(im['detections']) == 0):
             continue
     
         boxes = []
@@ -282,40 +283,52 @@ def in_place_nms(md_results, iou_thres=0.45, verbose=True):
 
 def _extract_tiles_for_image(fn_relative,image_folder,tiling_folder,patch_size,patch_stride,overwrite):
     """
-    Extract tiles for a single image
+    Private function to extract tiles for a single image.
     
-    Not really a standalone function; isolated from the main function to simplify
-    multiprocessing.
+    Returns a dict with fields 'patches' (see extract_patch_from_image) and 'image_fn'.
+    
+    If there is an error, 'patches' will be None and the 'error' field will contain
+    failure details.  In that case, some tiles may still be generated.
     """
     
     fn_abs = os.path.join(image_folder,fn_relative)
+    error = None
+    patches = []        
     
     image_name = path_utils.clean_filename(fn_relative,char_limit=None,force_lower=True)
     
-    # Open the image
-    im = vis_utils.open_image(fn_abs)
-    image_size = [im.width,im.height]
+    try:
+        
+        # Open the image
+        im = vis_utils.open_image(fn_abs)
+        image_size = [im.width,im.height]
+                
+        # Generate patch boundaries (a list of [x,y] starting points)
+        patch_boundaries = get_patch_boundaries(image_size,patch_size,patch_stride)        
+        
+        # Extract patches
+        #
+        # patch_xy = patch_boundaries[0]        
+        for patch_xy in patch_boundaries:
             
-    # Generate patch boundaries (a list of [x,y] starting points)
-    patch_boundaries = get_patch_boundaries(image_size,patch_size,patch_stride)        
-    
-    # Extract patches
-    #
-    # patch_xy = patch_boundaries[0]
-    patches = []
-    
-    for patch_xy in patch_boundaries:
+            patch_info = extract_patch_from_image(im,patch_xy,patch_size,
+                                     patch_folder=tiling_folder,
+                                     image_name=image_name,
+                                     overwrite=overwrite)
+            patch_info['source_fn'] = fn_relative
+            patches.append(patch_info)
         
-        patch_info = extract_patch_from_image(im,patch_xy,patch_size,
-                                 patch_folder=tiling_folder,
-                                 image_name=image_name,
-                                 overwrite=overwrite)
-        patch_info['source_fn'] = fn_relative
-        patches.append(patch_info)
+    except Exception as e:
+        
+        s = 'Patch generation error for {}: \n{}'.format(fn_relative,str(e))
+        print(s)
+        # patches = None
+        error = s
         
     image_patch_info = {}
     image_patch_info['patches'] = patches
     image_patch_info['image_fn'] = fn_relative
+    image_patch_info['error'] = error
     
     return image_patch_info
     
@@ -327,7 +340,8 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
                         checkpoint_path=None, checkpoint_frequency=-1, remove_tiles=False, 
                         yolo_inference_options=None,
                         n_patch_extraction_workers=default_n_patch_extraction_workers,
-                        overwrite_tiles=True):
+                        overwrite_tiles=True,
+                        image_list=None):
     """
     Run inference using [model_file] on the images in [image_folder], fist splitting each image up 
     into tiles of size [tile_size_x] x [tile_size_y], writing those tiles to [tiling_folder],
@@ -337,7 +351,8 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     [tiling_folder] can be any folder, but this function reserves the right to do whatever it wants
     within that folder, including deleting everything, so it's best if it's a new folder.  
     Conceptually this folder is temporary, it's just helpful in this case to not actually
-    use the system temp folder, because the tile cache may be very large, 
+    use the system temp folder, because the tile cache may be very large, so the caller may 
+    want it to be on a specific drive.
     
     tile_overlap is the fraction of overlap between tiles.
     
@@ -346,25 +361,54 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     if yolo_inference_options is supplied, it should be an instance of YoloInferenceOptions; in 
     this case the model will be run with run_inference_with_yolov5_val.  This is typically used to 
     run the model with test-time augmentation.          
-    """    
+    """
 
     ##%% Validate arguments
     
     assert tile_overlap < 1 and tile_overlap >= 0, \
         'Illegal tile overlap value {}'.format(tile_overlap)
     
+    if tile_size_x == -1:
+        tile_size_x = default_tile_size[0]
+    if tile_size_y == -1:
+        tile_size_y = default_tile_size[1]
+        
     patch_size = [tile_size_x,tile_size_y]
     patch_stride = (round(patch_size[0]*(1.0-tile_overlap)),
                     round(patch_size[1]*(1.0-tile_overlap)))
     
     os.makedirs(tiling_folder,exist_ok=True)
     
-    
     ##%% List files
     
-    image_files_relative = path_utils.find_images(image_folder, recursive=True, return_relative_paths=True)    
-    assert len(image_files_relative) > 0, 'No images found in folder {}'.format(image_folder)
-    
+    if image_list is None:
+        
+        print('Enumerating images in {}'.format(image_folder))
+        image_files_relative = path_utils.find_images(image_folder, recursive=True, return_relative_paths=True)    
+        assert len(image_files_relative) > 0, 'No images found in folder {}'.format(image_folder)
+        
+    else:
+        
+        print('Loading image list from {}'.format(image_list))
+        with open(image_list,'r') as f:
+            image_files_relative = json.load(f)
+        n_absolute_paths = 0
+        for i_fn,fn in enumerate(image_files_relative):
+            if os.path.isabs(fn):
+                n_absolute_paths += 1
+                try:
+                    fn_relative = os.path.relpath(fn,image_folder)
+                except ValueError:
+                    'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
+                        fn,image_folder)
+                    raise
+                assert not fn_relative.startswith('..'), \
+                    'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
+                        fn,image_folder)
+                image_files_relative[i_fn] = fn_relative
+        if (n_absolute_paths != 0) and (n_absolute_paths != len(image_files_relative)):
+            raise ValueError('Illegal file list: converted {} of {} paths to relative'.format(
+            n_absolute_paths,len(image_files_relative)))
     
     ##%% Generate tiles
     
@@ -414,7 +458,7 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
                 image_files_relative),total=len(image_files_relative)))
         
     # ...for each image
-        
+    
     # Write tile information to file; this is just a debugging convenience
     folder_name = path_utils.clean_filename(image_folder,force_lower=True)
     if folder_name.startswith('_'):
@@ -424,9 +468,16 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     with open(tile_cache_file,'w') as f:
         json.dump(all_image_patch_info,f,indent=1)
     
+    # Keep track of patches that failed
+    images_with_patch_errors = {}
+    for patch_info in all_image_patch_info:
+        if patch_info['error'] is not None:
+            images_with_patch_errors[patch_info['image_fn']] = patch_info
+    
     
     ##%% Run inference on tiles
     
+    # When running with run_inference_with_yolov5_val, we'll pass the folder
     if yolo_inference_options is not None:
         
         patch_level_output_file = os.path.join(tiling_folder,folder_name + '_patch_level_results.json')
@@ -444,11 +495,16 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
         run_inference_with_yolo_val(yolo_inference_options)
         with open(patch_level_output_file,'r') as f:
             patch_level_results = json.load(f)
-                    
+    
+    # For standard inference, we'll pass a list of files
     else:
         
         patch_file_names = []
         for im in all_image_patch_info:
+            # If there was a patch generation error, don't run inference 
+            if patch_info['error'] is not None:
+                assert im['image_fn'] in images_with_patch_errors
+                continue
             for patch in im['patches']:
                 patch_file_names.append(patch['patch_fn'])
                 
@@ -481,18 +537,44 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     image_fn_relative_to_patch_info = { x['image_fn']:x for x in all_image_patch_info }
     
     # i_image = 0; image_fn_relative = image_files_relative[i_image]
-    for i_image,image_fn_relative in tqdm(enumerate(image_files_relative),total=len(image_files_relative)):
+    for i_image,image_fn_relative in tqdm(enumerate(image_files_relative),
+                                          total=len(image_files_relative)):
         
         image_fn_abs = os.path.join(image_folder,image_fn_relative)
         assert os.path.isfile(image_fn_abs)
                 
         output_im = {}
         output_im['file'] = image_fn_relative
-        output_im['detections'] = []
+        
+        # If we had a patch generation error
+        if image_fn_relative in images_with_patch_errors:
             
-        pil_im = vis_utils.open_image(image_fn_abs)        
-        image_w = pil_im.size[0]
-        image_h = pil_im.size[1]
+            patch_info = image_fn_relative_to_patch_info[image_fn_relative]
+            assert patch_info['error'] is not None
+            
+            output_im['detections'] = None
+            output_im['failure'] = 'Patch generation error'
+            output_im['failure_details'] = patch_info['error']
+            image_level_results['images'].append(output_im)
+            continue
+                    
+        try:
+            pil_im = vis_utils.open_image(image_fn_abs)        
+            image_w = pil_im.size[0]
+            image_h = pil_im.size[1]
+        
+        # This would be a very unusual situation; we're reading back an image here that we already
+        # (successfully) read once during patch generation.
+        except Exception as e:
+            print('Warning: image read error after successful patch generation for {}:\n{}'.format(
+                image_fn_relative,str(e)))
+            output_im['detections'] = None
+            output_im['failure'] = 'Patch processing error'
+            output_im['failure_details'] = str(e)
+            image_level_results['images'].append(output_im)
+            continue            
+        
+        output_im['detections'] = []
         
         image_patch_info = image_fn_relative_to_patch_info[image_fn_relative]
         assert image_patch_info['patches'][0]['source_fn'] == image_fn_relative
@@ -520,6 +602,14 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
             assert patch_w == patch_size[0]
             assert patch_h == patch_size[1]
             
+            # If there was an inference failure on one patch, report the image
+            # as an inference failure
+            if 'detections' not in patch_results:
+                assert 'failure' in patch_results
+                output_im['detections'] = None
+                output_im['failure'] = patch_results['failure']
+                break
+            
             # det = patch_results['detections'][0]
             for det in patch_results['detections']:
             
@@ -703,7 +793,7 @@ def main():
         help='Path to detector model file (.pb or .pt)')
     parser.add_argument(
         'image_folder',
-        help='Folder containing images for inference (always recursive)')
+        help='Folder containing images for inference (always recursive, unless image_list is supplied)')
     parser.add_argument(
         'tiling_folder',
         help='Temporary folder where tiles and intermediate results will be stored')
@@ -729,6 +819,16 @@ def main():
         type=float,
         default=default_patch_overlap,
         help=('Overlap between tiles [0,1] (defaults to {})'.format(default_patch_overlap)))
+    parser.add_argument(
+        '--overwrite_handling',
+        type=str,
+        default='skip',
+        help=('behavior when the targt file exists (skip/overwrite/error) (default skip)'))
+    parser.add_argument(
+        '--image_list',
+        type=str,
+        default=None,
+        help=('a .json list of relative filenames (or absolute paths contained within image_folder) to include'))
         
     if len(sys.argv[1:]) == 0:
         parser.print_help()
@@ -736,19 +836,29 @@ def main():
 
     args = parser.parse_args()
 
-    assert os.path.exists(args.model_file), \
+    model_file = try_download_known_detector(args.model_file)
+    assert os.path.exists(model_file), \
         'detector file {} does not exist'.format(args.model_file)
-    
+        
     if os.path.exists(args.output_file):
-        print('Warning: output_file {} already exists and will be overwritten'.format(
-            args.output_file))
+        if args.overwrite_handling == 'skip':
+            print('Warning: output file {} exists, skipping'.format(args.output_file))
+            return
+        elif args.overwrite_handling == 'overwrite':
+            print('Warning: output file {} exists, overwriting'.format(args.output_file))
+        elif args.overwrite_handling == 'error':
+            raise ValueError('Output file {} exists'.format(args.output_file))
+        else:
+            raise ValueError('Unknown output handling method {}'.format(args.overwrite_handling))
+        
 
     remove_tiles = (not args.no_remove_tiles)
 
-    run_tiled_inference(args.model_file, args.image_folder, args.tiling_folder, args.output_file,
+    run_tiled_inference(model_file, args.image_folder, args.tiling_folder, args.output_file,
                         tile_size_x=args.tile_size_x, tile_size_y=args.tile_size_y, 
                         tile_overlap=args.tile_overlap,
-                        remove_tiles=remove_tiles)
+                        remove_tiles=remove_tiles,
+                        image_list=args.image_list)
         
 if __name__ == '__main__':
     main()

detection/video_utils.py

@@ -24,6 +24,8 @@ from md_utils import path_utils
     
 from md_visualization import visualization_utils as vis_utils
 
+default_fourcc = 'h264'
+
 
 #%% Path utilities
 
@@ -76,7 +78,7 @@ def find_videos(dirname: str, recursive: bool = False,
 
 # http://tsaith.github.io/combine-images-into-a-video-with-python-3-and-opencv-3.html
 
-def frames_to_video(images, Fs, output_file_name, codec_spec='h264'):
+def frames_to_video(images, Fs, output_file_name, codec_spec=default_fourcc):
     """
     Given a list of image files and a sample rate, concatenate those images into
     a video and write to [output_file_name].