megadetector 5.0.18__py3-none-any.whl → 5.0.20__py3-none-any.whl

megadetector/data_management/yolo_output_to_md_output.py

@@ -301,7 +301,7 @@ def yolo_json_output_to_md_output(yolo_json_file,
     
     d = {}
     d['images'] = output_images
-    d['info'] = {'format_version':1.3,'detector':detector_name}
+    d['info'] = {'format_version':'1.4','detector':detector_name}
     d['detection_categories'] = {}
         
     for cat_id in yolo_category_id_to_name:
@@ -411,7 +411,7 @@ def yolo_txt_output_to_md_output(input_results_folder,
         'info': {
             'detector': detector_string,
             'detector_metadata': {},
-            'format_version': '1.3'
+            'format_version': '1.4'
         },
         'detection_categories': {
             '1': 'animal',

megadetector/detection/process_video.py

@@ -5,12 +5,10 @@ process_video.py
 Splits a video (or folder of videos) into frames, runs the frames through run_detector_batch.py,
 and optionally stitches together results into a new video with detection boxes.
 
-Operates by separating the video into frames, typically sampling every Nth frame, and writing
-those frames to disk, before running MD.  This approach clearly has a downside: it requires
-a bunch more disk space, compared to extracting frames and running MD on them without ever
-writing them to disk.  The upside, though, is that this approach allows you to run repeat
-detection elimination after running MegaDetector, and it allows allows more efficient re-use
-of frames if you end up running MD more than once, or running multiple versions of MD.
+When possible, video processing happens in memory, without writing intermediate frames to disk.
+If the caller requests that frames be saved, frames are written before processing, and the MD
+results correspond to the frames that were written to disk (which simplifies, for example,
+repeat detection elimination).
 
 """
 
@@ -36,6 +34,7 @@ from megadetector.detection.video_utils import run_callback_on_frames
 from megadetector.detection.video_utils import run_callback_on_frames_for_folder
 from megadetector.detection.video_utils import frames_to_video
 from megadetector.detection.video_utils import frame_results_to_video_results
+from megadetector.detection.video_utils import FrameToVideoOptions
 from megadetector.detection.video_utils import _add_frame_numbers_to_results
 from megadetector.detection.video_utils import video_folder_to_frames
 from megadetector.detection.video_utils import default_fourcc
@@ -133,13 +132,16 @@ class ProcessVideoOptions:
         
         #: Sample every Nth frame; set to None (default) or 1 to sample every frame.  Typically
         #: we sample down to around 3 fps, so for typical 30 fps videos, frame_sample=10 is a 
-        #: typical value.  Mutually exclusive with [frames_to_extract].
+        #: typical value.  Mutually exclusive with [frames_to_extract] and [time_sample].
         self.frame_sample = None
         
         #: Extract a specific set of frames (list of ints, or a single int).  Mutually exclusive with
-        #: [frame_sample].
+        #: [frame_sample] and [time_sample].
         self.frames_to_extract = None
         
+        # Sample frames every N seconds.  Mutally exclusive with [frame_sample] and [frames_to_extract].
+        self.time_sample = None
+        
         #: Number of workers to use for parallelization; set to <= 1 to disable parallelization
         self.n_cores = 1
     
@@ -172,11 +174,34 @@ class ProcessVideoOptions:
         #: frame from each video, but a video only has 50 frames.
         self.allow_empty_videos = False
     
+        #: When processing a folder of videos, should we include just a single representative 
+        #: frame result for each video (default), or every frame that was processed?
+        self.include_all_processed_frames = False
+        
 # ...class ProcessVideoOptions
 
 
 #%% Functions
 
+def _validate_video_options(options):
+    """
+    Consistency checking for ProcessVideoOptions objects.
+    """
+    
+    n_sampling_options_configured = 0
+    if options.frame_sample is not None:
+        n_sampling_options_configured += 1
+    if options.time_sample is not None:
+        n_sampling_options_configured += 1
+    if options.frames_to_extract is not None:
+        n_sampling_options_configured += 1
+    
+    if n_sampling_options_configured > 1:
+        raise ValueError('frame_sample, time_sample, and frames_to_extract are mutually exclusive')
+    
+    return True
+        
+    
 def _select_temporary_output_folders(options):
     """
     Choose folders in system temp space for writing temporary frames.  Does not create folders,
@@ -330,12 +355,19 @@ def process_video(options):
         dict: frame-level MegaDetector results, identical to what's in the output .json file
     """
 
+    # Check for incompatible options
+    _validate_video_options(options)
+    
     if options.output_json_file is None:
         options.output_json_file = options.input_video_file + '.json'
 
     if options.render_output_video and (options.output_video_file is None):
         options.output_video_file = options.input_video_file + '.detections.mp4'
 
+    if options.time_sample is not None:
+        raise ValueError('Time-based sampling is not supported when processing a single video; ' + \
+                         'consider processing a folder, or using frame_sample')
+        
     if options.model_file == 'no_detection' and not options.keep_extracted_frames:
         print('Warning: you asked for no detection, but did not specify keep_extracted_frames, this is a no-op')
         return
@@ -461,7 +493,8 @@ def process_video(options):
     
     if options.render_output_video:
         
-        # Render detections to images
+        ## Render detections to images
+        
         if (caller_provided_rendering_output_folder):
             rendering_output_dir = options.frame_rendering_folder
         else:
@@ -475,16 +508,24 @@ def process_video(options):
             images_dir=frame_output_folder,
             confidence_threshold=options.rendering_confidence_threshold)
 
-        # Combine into a video
+        
+        ## Choose the frame rate at which we should render the output video
+        
         if options.rendering_fs is not None:
             rendering_fs = options.rendering_fs
-        elif options.frame_sample is None:
+        elif options.frame_sample is None and options.time_sample is None:
             rendering_fs = Fs
-        else:
+        elif options.frame_sample is not None:
+            assert options.time_sample is None
             # If the original video was 30fps and we sampled every 10th frame, 
             # render at 3fps
             rendering_fs = Fs / options.frame_sample
+        elif options.time_sample is not None:
+            rendering_fs = options.time_sample
             
+        
+        ## Render the output video
+        
         print('Rendering {} frames to {} at {} fps (original video {} fps)'.format(
             len(detected_frame_files), options.output_video_file,rendering_fs,Fs))
         frames_to_video(detected_frame_files, 
@@ -499,6 +540,7 @@ def process_video(options):
     
     
     ## (Optionally) delete the extracted frames
+    
     _clean_up_extracted_frames(options, frame_output_folder, frame_filenames)
     
 # ...process_video()
@@ -521,6 +563,9 @@ def process_video_folder(options):
     
     ## Validate options
 
+    # Check for incompatible options
+    _validate_video_options(options)
+    
     assert os.path.isdir(options.input_video_file), \
         '{} is not a folder'.format(options.input_video_file)
            
@@ -548,6 +593,11 @@ def process_video_folder(options):
     image_file_names = None
     video_filename_to_fs = {}
     
+    if options.time_sample is not None:
+        every_n_frames_param = -1 * options.time_sample
+    else:
+        every_n_frames_param = options.frame_sample
+    
     # Run MD in memory if we don't need to generate frames
     #
     # Currently if we're generating an output video, we need to generate frames on disk first.
@@ -572,12 +622,13 @@ def process_video_folder(options):
         
         md_results = run_callback_on_frames_for_folder(input_video_folder=options.input_video_file, 
                                                        frame_callback=frame_callback,
-                                                       every_n_frames=options.frame_sample, 
+                                                       every_n_frames=every_n_frames_param,
                                                        verbose=options.verbose)
         
         video_results = md_results['results']
         
         for i_video,video_filename in enumerate(md_results['video_filenames']):
+            video_filename = video_filename.replace('\\','/')
             assert video_filename not in video_filename_to_fs
             video_filename_to_fs[video_filename] = md_results['frame_rates'][i_video]
         
@@ -621,9 +672,11 @@ def process_video_folder(options):
                                    frames_to_extract=options.frames_to_extract,
                                    allow_empty_videos=options.allow_empty_videos)
         
-        for i_video,video_filename in enumerate(video_filenames):
-            assert video_filename not in video_filename_to_fs
-            video_filename_to_fs[video_filename] = Fs[i_video]
+        for i_video,video_filename_abs in enumerate(video_filenames):
+            video_filename_relative = os.path.relpath(video_filename_abs,options.input_video_file)
+            video_filename_relative = video_filename_relative.replace('\\','/')
+            assert video_filename_relative not in video_filename_to_fs
+            video_filename_to_fs[video_filename_relative] = Fs[i_video]
                 
         print('Extracted frames for {} videos'.format(len(set(video_filenames))))
         image_file_names = list(itertools.chain.from_iterable(frame_filenames))
@@ -676,8 +729,13 @@ def process_video_folder(options):
     
     ## Convert frame-level results to video-level results
 
+    frame_to_video_options = FrameToVideoOptions()
+    frame_to_video_options.include_all_processed_frames = options.include_all_processed_frames
+    
     print('Converting frame-level results to video-level results')
-    frame_results_to_video_results(frames_json,video_json,
+    frame_results_to_video_results(frames_json,
+                                   video_json,
+                                   options=frame_to_video_options,
                                    video_filename_to_frame_rate=video_filename_to_fs)
 
 
@@ -1085,10 +1143,17 @@ def main():
                             'a folder.  Default {}.'.format(default_options.n_cores))
 
     parser.add_argument('--frame_sample', type=int,
-                        default=None, help='process every Nth frame (defaults to every frame)')
+                        default=None, help='process every Nth frame (defaults to every frame), mutually exclusive '\
+                            'with --frames_to_extract and --time_sample.')
 
     parser.add_argument('--frames_to_extract', nargs='+', type=int,
-                        default=None, help='extract specific frames (one or more ints)')
+                        default=None, help='extract specific frames (one or more ints), mutually exclusive '\
+                            'with --frame_sample and --time_sample.')
+    
+    parser.add_argument('--time_sample', type=float,
+                        default=None, help='process frames every N seconds; this is converted to a '\
+                            'frame sampling rate, so it may not be exactly the requested interval in seconds. '\
+                            'mutually exclusive with --frame_sample and --frames_to_extract.')
 
     parser.add_argument('--quality', type=int,
                         default=default_options.quality, 
@@ -1124,6 +1189,12 @@ def main():
                         action='store_true',
                         help='Enable image augmentation')
     
+    parser.add_argument('--include_all_processed_frames',
+                        action='store_true',
+                        help='When processing a folder of videos, this flag indicates that the output  '\
+                             'should include results for every frame that was processed, rather than just '\
+                             'one representative frame for each detection category per video.')
+    
     parser.add_argument('--allow_empty_videos',
                         action='store_true',
                         help='By default, videos with no retrievable frames cause an error, this makes it a warning')

megadetector/detection/run_detector.py

@@ -356,22 +356,29 @@ def is_gpu_available(model_file):
                 pass
         return gpu_available
     else:
-        raise ValueError('Unrecognized model file extension for model {}'.format(model_file))
+        raise ValueError('Model {} does not have a recognized extension and is not a known model name'.\
+                         format(model_file))
 
 
-def load_detector(model_file, force_cpu=False):
+def load_detector(model_file, force_cpu=False, force_model_download=False):
     r"""
     Loads a TF or PT detector, depending on the extension of model_file.
     
     Args:
         model_file (str): model filename, e.g. c:/x/z/md_v5a.0.0.pt
+        force_cpu (bool, optional): force the model to run on the CPU even if a GPU
+            is available
+        force_model_download (bool, optional): force downloading the model file if
+            a named model (e.g. "MDV5A") is supplied, even if the local file already
+            exists
     
     Returns:
         object: loaded detector object
     """
     
     # Possibly automatically download the model
-    model_file = try_download_known_detector(model_file)
+    model_file = try_download_known_detector(model_file, 
+                                             force_download=force_model_download)
     
     start_time = time.time()
     if model_file.endswith('.pb'):
@@ -402,7 +409,8 @@ def load_and_run_detector(model_file,
                           box_expansion=DEFAULT_BOX_EXPANSION,
                           image_size=None,
                           label_font_size=DEFAULT_LABEL_FONT_SIZE,
-                          augment=False
+                          augment=False,
+                          force_model_download=False
                           ):
     r"""
     Loads and runs a detector on target images, and visualizes the results.
@@ -424,6 +432,9 @@ def load_and_run_detector(model_file,
         label_font_size (float, optional): font size to use for displaying class names
             and confidence values in the rendered images        
         augment (bool, optional): enable (implementation-specific) image augmentation
+        force_model_download (bool, optional): force downloading the model file if
+            a named model (e.g. "MDV5A") is supplied, even if the local file already
+            exists
     """
     
     if len(image_file_names) == 0:
@@ -431,7 +442,7 @@ def load_and_run_detector(model_file,
         return
 
     # Possibly automatically download the model
-    model_file = try_download_known_detector(model_file)
+    model_file = try_download_known_detector(model_file, force_download=force_model_download)
 
     print('GPU available: {}'.format(is_gpu_available(model_file)))
     
@@ -581,7 +592,7 @@ def download_model(model_name,force_download=False):
     
     Args:
         model_name (str): a known model string, e.g. "MDV5A"
-        force_download (bool, optional): whether download the model even if the local target 
+        force_download (bool, optional): whether to download the model even if the local target 
             file already exists
     """
     
@@ -597,17 +608,18 @@ def download_model(model_name,force_download=False):
         os.chmod(model_tempdir,0o777)
     except Exception:
         pass
-    if model_name not in downloadable_models:
+    if model_name.upper() not in downloadable_models:
         print('Unrecognized downloadable model {}'.format(model_name))
         return None
-    url = downloadable_models[model_name]
+    url = downloadable_models[model_name.upper()]
     destination_filename = os.path.join(model_tempdir,url.split('/')[-1])
     local_file = download_url(url, destination_filename=destination_filename, progress_updater=None, 
                      force_download=force_download, verbose=True)
+    print('Model {} available at {}'.format(model_name,local_file))
     return local_file
 
 
-def try_download_known_detector(detector_file):
+def try_download_known_detector(detector_file,force_download=False):
     """
     Checks whether detector_file is really the name of a known model, in which case we will
     either read the actual filename from the corresponding environment variable or download
@@ -616,13 +628,15 @@ def try_download_known_detector(detector_file):
     Args:
         detector_file (str): a known model string (e.g. "MDV5A"), or any other string (in which
             case this function is a no-op)
+        force_download (bool, optional): whether to download the model even if the local target 
+            file already exists
     
     Returns:
         str: the local filename to which the model was downloaded, or the same string that
         was passed in, if it's not recognized as a well-known model name
     """
     
-    if detector_file in downloadable_models:
+    if detector_file.upper() in downloadable_models:
         if detector_file in os.environ:
             fn = os.environ[detector_file]
             print('Reading MD location from environment variable {}: {}'.format(
@@ -630,7 +644,7 @@ def try_download_known_detector(detector_file):
             detector_file = fn
         else:
             print('Downloading model {}'.format(detector_file))
-            detector_file = download_model(detector_file)
+            detector_file = download_model(detector_file,force_download=force_download)
     return detector_file
         
     
@@ -725,6 +739,12 @@ def main():
               .format(DETECTION_FILENAME_INSERT) + \
               'This option disables that behavior.'))
     
+    parser.add_argument(
+        '--force_model_download',
+        action='store_true',
+        help=('If a named model (e.g. "MDV5A") is supplied, force a download of that model even if the ' +\
+              'local file already exists.'))
+        
     if len(sys.argv[1:]) == 0:
         parser.print_help()
         parser.exit()
@@ -733,7 +753,8 @@ def main():
 
     # If the specified detector file is really the name of a known model, find 
     # (and possibly download) that model
-    args.detector_file = try_download_known_detector(args.detector_file)
+    args.detector_file = try_download_known_detector(args.detector_file,
+                                                     force_download=args.force_model_download)
     
     assert os.path.exists(args.detector_file), 'detector file {} does not exist'.format(
         args.detector_file)
@@ -774,7 +795,9 @@ def main():
                           crop_images=args.crop,
                           image_size=args.image_size,
                           label_font_size=args.label_font_size,
-                          augment=args.augment)
+                          augment=args.augment,
+                          # Don't download the model *again*
+                          force_model_download=False)
 
 if __name__ == '__main__':
     main()

megadetector/detection/run_detector_batch.py

@@ -510,7 +510,8 @@ def load_and_run_detector_batch(model_file,
                                 include_image_size=False, 
                                 include_image_timestamp=False, 
                                 include_exif_data=False,
-                                augment=False):
+                                augment=False,
+                                force_model_download=False):
     """
     Load a model file and run it on a list of images.
     
@@ -539,6 +540,9 @@ def load_and_run_detector_batch(model_file,
         include_image_timestamp (bool, optional): should we include image timestamps in the output for each image?
         include_exif_data (bool, optional): should we include EXIF data in the output for each image?
         augment (bool, optional): enable image augmentation
+        force_model_download (bool, optional): force downloading the model file if
+            a named model (e.g. "MDV5A") is supplied, even if the local file already
+            exists
         
     Returns:
         results: list of dicts; each dict represents detections on one image
@@ -599,7 +603,7 @@ def load_and_run_detector_batch(model_file,
 
     already_processed = set([i['file'] for i in results])
 
-    model_file = try_download_known_detector(model_file)
+    model_file = try_download_known_detector(model_file, force_download=force_model_download)
         
     print('GPU available: {}'.format(is_gpu_available(model_file)))
     
@@ -886,7 +890,7 @@ def write_results_to_file(results,
         
         info = { 
             'detection_completion_time': datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S'),
-            'format_version': '1.3' 
+            'format_version': '1.4' 
         }
         
         if detector_file is not None:
@@ -902,8 +906,7 @@ def write_results_to_file(results,
     # If the caller supplied the entire "info" struct
     else:
         
-        if detector_file is not None:
-            
+        if detector_file is not None:            
             print('Warning (write_results_to_file): info struct and detector file ' + \
                   'supplied, ignoring detector file')
 
@@ -1145,8 +1148,21 @@ def main():
         type=str,
         default='overwrite',
         help='What should we do if the output file exists?  overwrite/skip/error (default overwrite)'
-    )
-    
+    )    
+    parser.add_argument(
+        '--force_model_download',
+        action='store_true',
+        help=('If a named model (e.g. "MDV5A") is supplied, force a download of that model even if the ' +\
+              'local file already exists.'))
+    parser.add_argument(
+        '--previous_results_file',
+        type=str,
+        default=None,
+        help=('If supplied, this should point to a previous .json results file; any results in that ' +\
+              'file will be transferred to the output file without reprocessing those images.  Useful ' +\
+              'for "updating" a set of results when you may have added new images to a folder you\'ve ' +\
+              'already processed.  Only supported when using relative paths.'))
+        
     if len(sys.argv[1:]) == 0:
         parser.print_help()
         parser.exit()
@@ -1155,7 +1171,8 @@ def main():
 
     # If the specified detector file is really the name of a known model, find 
     # (and possibly download) that model
-    args.detector_file = try_download_known_detector(args.detector_file)
+    args.detector_file = try_download_known_detector(args.detector_file, 
+                                                     force_download=args.force_model_download)
     
     assert os.path.exists(args.detector_file), \
         'detector file {} does not exist'.format(args.detector_file)
@@ -1167,7 +1184,9 @@ def main():
         assert os.path.isdir(args.image_file), \
             f'Could not find folder {args.image_file}, must supply a folder when ' + \
                 '--output_relative_filenames is set'
-
+    if args.previous_results_file is not None:
+        assert os.path.isdir(args.image_file) and args.output_relative_filenames, \
+            "Can only process previous results when using relative paths"
     if os.path.exists(args.output_file):
         if args.overwrite_handling == 'overwrite':
             print('Warning: output file {} already exists and will be overwritten'.format(
@@ -1193,8 +1212,8 @@ def main():
     
     # Load the checkpoint if available
     #
-    # Relative file names are only output at the end; all file paths in the checkpoint are
-    # still absolute paths.
+    # File paths in the checkpoint are always absolute paths; conversion to relative paths
+    # happens below (if necessary).
     if args.resume_from_checkpoint is not None:
         if args.resume_from_checkpoint == 'auto':
             checkpoint_files = os.listdir(output_dir)
@@ -1225,7 +1244,7 @@ def main():
     else:
         results = []
 
-    # Find the images to score; images can be a directory, may need to recurse
+    # Find the images to process; images can be a directory, may need to recurse
     if os.path.isdir(args.image_file):
         image_file_names = path_utils.find_images(args.image_file, args.recursive)
         if len(image_file_names) > 0:
@@ -1240,7 +1259,7 @@ def main():
             return
         
     # A json list of image paths
-    elif os.path.isfile(args.image_file) and args.image_file.endswith('.json'):
+    elif os.path.isfile(args.image_file) and args.image_file.endswith('.json'):        
         with open(args.image_file) as f:
             image_file_names = json.load(f)
         print('Loaded {} image filenames from .json list file {}'.format(
@@ -1263,10 +1282,62 @@ def main():
         raise ValueError('image_file specified is not a directory, a json list, or an image file, '
                          '(or does not have recognizable extensions).')
 
+    # At this point, regardless of how they were specified, [image_file_names] is a list of 
+    # absolute image paths.
     assert len(image_file_names) > 0, 'Specified image_file does not point to valid image files'
+    
+    # Convert to forward slashes to facilitate comparison with previous results
+    image_file_names = [fn.replace('\\','/') for fn in image_file_names]
+    
+    # We can head off many problems related to incorrect command line formulation if we confirm
+    # that one image exists before proceeding.  The use of the first image for this test is 
+    # arbitrary.
     assert os.path.exists(image_file_names[0]), \
         'The first image to be processed does not exist at {}'.format(image_file_names[0])
 
+    # Possibly load results from a previous pass
+    previous_results = None
+    
+    if args.previous_results_file is not None:
+        
+        assert os.path.isfile(args.previous_results_file), \
+            'Could not find previous results file {}'.format(args.previous_results_file)
+        with open(args.previous_results_file,'r') as f:
+            previous_results = json.load(f)
+                
+        assert previous_results['detection_categories'] == run_detector.DEFAULT_DETECTOR_LABEL_MAP, \
+            "Can't merge previous results when those results use a different set of detection categories"
+        
+        print('Loaded previous results for {} images from {}'.format(
+            len(previous_results['images']), args.previous_results_file))
+        
+        # Convert previous result filenames to absolute paths if necessary 
+        #
+        # We asserted above to make sure that we are using relative paths and processing a 
+        # folder, but just to be super-clear...
+        assert os.path.isdir(args.image_file)
+        
+        previous_image_files_set = set()
+        for im in previous_results['images']:
+            assert not os.path.isabs(im['file']), \
+                "When processing previous results, relative paths are required"
+            fn_abs = os.path.join(args.image_file,im['file']).replace('\\','/')
+            # Absolute paths are expected at the final output stage below
+            im['file'] = fn_abs
+            previous_image_files_set.add(fn_abs)            
+        
+        image_file_names_to_keep = []
+        for fn_abs in image_file_names:
+            if fn_abs not in previous_image_files_set:
+                image_file_names_to_keep.append(fn_abs)
+                
+        print('Based on previous results file, processing {} of {} images'.format(
+            len(image_file_names_to_keep), len(image_file_names)))
+        
+        image_file_names = image_file_names_to_keep
+        
+    # ...if we're handling previous results
+        
     # Test that we can write to the output_file's dir if checkpointing requested
     if args.checkpoint_frequency != -1:
         
@@ -1322,7 +1393,9 @@ def main():
                                           include_image_size=args.include_image_size,
                                           include_image_timestamp=args.include_image_timestamp,
                                           include_exif_data=args.include_exif_data,
-                                          augment=args.augment)
+                                          augment=args.augment,
+                                          # Don't download the model *again*
+                                          force_model_download=False)
 
     elapsed = time.time() - start_time
     images_per_second = len(results) / elapsed
@@ -1330,10 +1403,26 @@ def main():
         len(results),humanfriendly.format_timespan(elapsed),images_per_second))
 
     relative_path_base = None
+    
+    # We asserted above to make sure that if output_relative_filenames is set, 
+    # args.image_file is a folder, but we'll double-check for clarity.
     if args.output_relative_filenames:
+        assert os.path.isdir(args.image_file)
         relative_path_base = args.image_file
-    write_results_to_file(results, args.output_file, relative_path_base=relative_path_base,
-                          detector_file=args.detector_file,include_max_conf=args.include_max_conf)
+    
+    # Merge results from a previous file if necessary
+    if previous_results is not None:
+        previous_filenames_set = set([im['file'] for im in previous_results['images']])
+        new_filenames_set = set([im['file'] for im in results])
+        assert len(previous_filenames_set.intersection(new_filenames_set)) == 0, \
+            'Previous results handling error: redundant image filenames'
+        results.extend(previous_results['images'])        
+        
+    write_results_to_file(results, 
+                          args.output_file, 
+                          relative_path_base=relative_path_base,
+                          detector_file=args.detector_file,
+                          include_max_conf=args.include_max_conf)
 
     if checkpoint_path and os.path.isfile(checkpoint_path):
         os.remove(checkpoint_path)