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

megadetector/detection/run_detector.py

@@ -114,6 +114,8 @@ DETECTION_FILENAME_INSERT = '_detections'
 # automatic model download to the system temp folder, or they will use the paths specified in the 
 # $MDV4, $MDV5A, or $MDV5B environment variables if they exist.
 downloadable_models = {
+    'MDV2':'https://lila.science/public/models/megadetector/megadetector_v2.pb',
+    'MDV3':'https://lila.science/public/models/megadetector/megadetector_v3.pb',
     'MDV4':'https://github.com/agentmorris/MegaDetector/releases/download/v4.1/md_v4.1.0.pb',
     'MDV5A':'https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5a.0.0.pt',
     'MDV5B':'https://github.com/agentmorris/MegaDetector/releases/download/v5.0/md_v5b.0.0.pt'
@@ -197,7 +199,7 @@ def get_detector_metadata_from_version_string(detector_version):
         return DETECTOR_METADATA[detector_version]
 
 
-def get_detector_version_from_filename(detector_filename):
+def get_detector_version_from_filename(detector_filename,accept_first_match=True):
     r"""
     Gets the version number component of the detector from the model filename.  
     
@@ -215,6 +217,8 @@ def get_detector_version_from_filename(detector_filename):
     
     Args:
         detector_filename (str): model filename, e.g. c:/x/z/md_v5a.0.0.pt
+        accept_first_match (bool, optional): if multiple candidates match the filename, choose the 
+            first one, otherwise returns the string "multiple"
     
     Returns:
         str: a detector version string, e.g. "v5a.0.0", or "multiple" if I'm confused
@@ -230,7 +234,10 @@ def get_detector_version_from_filename(detector_filename):
         return 'unknown'
     elif len(matches) > 1:
         print('Warning: multiple MegaDetector versions for model file {}'.format(detector_filename))
-        return 'multiple'
+        if accept_first_match:
+            return model_string_to_model_version[matches[0]]
+        else:
+            return 'multiple'
     else:
         return model_string_to_model_version[matches[0]]
     

megadetector/detection/run_detector_batch.py

@@ -846,7 +846,7 @@ def write_results_to_file(results,
     https://github.com/agentmorris/MegaDetector/tree/main/megadetector/api/batch_processing#batch-processing-api-output-format
 
     Args:
-        results (list):  list of dict, each dict represents detections on one image
+        results (list): list of dict, each dict represents detections on one image
         output_file (str): path to JSON output file, should end in '.json'
         relative_path_base (str, optional): path to a directory as the base for relative paths, can
             be None if the paths in [results] are absolute
@@ -923,6 +923,13 @@ def write_results_to_file(results,
         'info': info
     }
     
+    # Create the folder where the output file belongs; this will fail if
+    # this is a relative path with no folder component
+    try:
+        os.makedirs(os.path.dirname(output_file),exist_ok=True)
+    except Exception:
+        pass
+    
     with open(output_file, 'w') as f:
         json.dump(final_output, f, indent=1, default=str)
     print('Output file saved at {}'.format(output_file))

megadetector/detection/run_inference_with_yolov5_val.py

@@ -106,7 +106,9 @@ class YoloInferenceOptions:
     
         #: Image size to use; this is a single int, which in ultralytics's terminology means
         #: "scale the long side of the image to this size, and preserve aspect ratio".
-        self.image_size = default_image_size_with_augmentation
+        #:
+        #: If None, will choose based on whether augmentation is enabled.
+        self.image_size = None
         
         #: Detections below this threshold will not be included in the output file
         self.conf_thres = '0.001'
@@ -276,10 +278,10 @@ def run_inference_with_yolo_val(options):
     
     if options.input_folder is not None:
         options.input_folder = options.input_folder.replace('\\','/')
+                
         
-
     ##%% Other input handling
-    
+        
     if isinstance(options.yolo_category_id_to_name,str):
         
         assert os.path.isfile(options.yolo_category_id_to_name)
@@ -328,7 +330,9 @@ def run_inference_with_yolo_val(options):
     image_files_relative = None
     image_files_absolute = None
     
+    # If the caller just provided a folder, not a list of files...
     if options.image_filename_list is None:
+        
         assert options.input_folder is not None and os.path.isdir(options.input_folder), \
             'Could not find input folder {}'.format(options.input_folder)
         image_files_relative = path_utils.find_images(options.input_folder,
@@ -337,18 +341,23 @@ def run_inference_with_yolo_val(options):
                                                       convert_slashes=True)
         image_files_absolute = [os.path.join(options.input_folder,fn) for \
                                 fn in image_files_relative]
+            
     else:
         
-        if is_iterable(options.image_filename_list):
+        # If the caller provided a list of image files (rather than a filename pointing 
+        # to a list of image files)...
+        if is_iterable(options.image_filename_list) and not isinstance(options.image_filename_list,str):
             
             image_files_relative = options.image_filename_list
             
+        # If the caller provided a filename pointing to a list of image files...
         else:
+            
             assert isinstance(options.image_filename_list,str), \
                 'Unrecognized image filename list object type: {}'.format(options.image_filename_list)
             assert os.path.isfile(options.image_filename_list), \
                 'Could not find image filename list file: {}'.format(options.image_filename_list)
-            ext = os.path.splitext(options.image_filename_list).lower()
+            ext = os.path.splitext(options.image_filename_list)[-1].lower()
             assert ext in ('.json','.txt'), \
                 'Unrecognized image filename list file extension: {}'.format(options.image_filename_list)
             if ext == '.json':
@@ -364,8 +373,11 @@ def run_inference_with_yolo_val(options):
         # ...whether the image filename list was supplied as list vs. a filename
         
         if options.input_folder is None:
+            
             image_files_absolute = image_files_relative
+            
         else:
+            
             # The list should be relative filenames
             for fn in image_files_relative:
                 assert not path_is_abs(fn), \
@@ -373,12 +385,14 @@ def run_inference_with_yolo_val(options):
                 
             image_files_absolute = \
                 [os.path.join(options.input_folder,fn) for fn in image_files_relative]
+        
         for fn in image_files_absolute:
             assert os.path.isfile(fn), 'Could not find image file {}'.format(fn)
     
     # ...whether the caller supplied a list of filenames
     
     image_files_absolute = [fn.replace('\\','/') for fn in image_files_absolute]
+    
     del image_files_relative
     
     
@@ -549,6 +563,7 @@ def run_inference_with_yolo_val(options):
         for i_image,image_fn in tqdm(enumerate(image_files_absolute),total=len(image_files_absolute)):
             
             ext = os.path.splitext(image_fn)[1]
+            image_fn_without_extension = os.path.splitext(image_fn)[0]
             
             # YOLO .json output identifies images by the base filename without the extension
             image_id = str(i_image).zfill(10)
@@ -557,12 +572,25 @@ def run_inference_with_yolo_val(options):
             symlink_full_path = os.path.join(symlink_folder_inner,symlink_name)
             link_full_paths.append(symlink_full_path)
             
+            # If annotation files exist, link those too; only useful if we're reading the computed
+            # mAP value, but it doesn't hurt.
+            annotation_fn = image_fn_without_extension + '.txt'
+            annotation_file_exists = False
+            if os.path.isfile(annotation_fn):
+                annotation_file_exists = True
+                annotation_symlink_name = image_id + '.txt'
+                annotation_symlink_full_path = os.path.join(symlink_folder_inner,annotation_symlink_name)                
+            
             try:
                 
                 if options.use_symlinks:
                     path_utils.safe_create_link(image_fn,symlink_full_path)
+                    if annotation_file_exists:
+                        path_utils.safe_create_link(annotation_fn,annotation_symlink_full_path)
                 else:
                     shutil.copyfile(image_fn,symlink_full_path)
+                    if annotation_file_exists:
+                        shutil.copyfile(annotation_fn,annotation_symlink_full_path)
                     
             except Exception as e:
                 
@@ -648,7 +676,15 @@ def run_inference_with_yolo_val(options):
 
     ##%% Prepare Python command or YOLO CLI command
     
-    image_size_string = str(round(options.image_size))
+    if options.image_size is None:
+        if options.augment:
+            image_size = default_image_size_with_augmentation
+        else:
+            image_size = default_image_size_with_no_augmentation
+    else:
+        image_size = options.image_size
+    
+    image_size_string = str(round(image_size))
     
     if options.model_type == 'yolov5':
         
@@ -659,6 +695,9 @@ def run_inference_with_yolo_val(options):
         cmd += ' --device "{}" --save-json'.format(options.device_string)
         cmd += ' --project "{}" --name "{}" --exist-ok'.format(yolo_results_folder,'yolo_results')
         
+        # This is the NMS IoU threshold
+        # cmd += ' --iou-thres 0.6'
+        
         if options.augment:
             cmd += ' --augment'
                 
@@ -837,7 +876,7 @@ def run_inference_with_yolo_val(options):
     _clean_up_temporary_folders(options,
                                 symlink_folder,yolo_results_folder,
                                 symlink_folder_is_temp_folder,yolo_folder_is_temp_folder)
-        
+    
 # ...def run_inference_with_yolo_val()
 
 
@@ -856,7 +895,7 @@ def main():
         help='model file name')
     parser.add_argument(
         'input_folder',type=str,
-        help='folder on which to recursively run the model')
+        help='folder on which to recursively run the model, or a .json or .txt file containing a list of absolute image paths')
     parser.add_argument(
         'output_file',type=str,
         help='.json file where output will be written')
@@ -967,7 +1006,15 @@ def main():
     
     if args.yolo_dataset_file is not None:
         options.yolo_category_id_to_name = args.yolo_dataset_file
-        del options.yolo_dataset_file
+    
+    # The function convention is that input_folder should be None when we want to use a list of 
+    # absolute paths, but the CLI convention is that the required argument is always valid, whether 
+    # it's a folder or a list of absolute paths.
+    if os.path.isfile(options.input_folder):
+        assert options.image_filename_list is None, \
+            'image_filename_list should not be specified when input_folder is a file'
+        options.image_filename_list = options.input_folder
+        options.input_folder = None        
         
     options.recursive = (not options.nonrecursive)
     options.remove_symlink_folder = (not options.no_remove_symlink_folder)
@@ -980,6 +1027,7 @@ def main():
     del options.no_remove_yolo_results_folder
     del options.no_use_symlinks
     del options.augment_enabled
+    del options.yolo_dataset_file
         
     print(options.__dict__)
     
@@ -1001,7 +1049,7 @@ if False:
     yolo_working_folder = r'c:\git\yolov5-tegus'
     dataset_file = r'g:\temp\dataset.yaml'
     
-    # This only impacts the output file name, it's not passed to the inference functio
+    # This only impacts the output file name, it's not passed to the inference function
     job_name = 'yolo-inference-test'
     
     model_name = os.path.splitext(os.path.basename(model_filename))[0]

megadetector/detection/tf_detector.py

@@ -110,7 +110,10 @@ class TFDetector:
         Runs the detector on a single image.
         """
         
-        np_im = np.asarray(image, np.uint8)
+        if isinstance(image,np.ndarray):
+            np_im = image
+        else:
+            np_im = np.asarray(image, np.uint8)
         im_w_batch_dim = np.expand_dims(np_im, axis=0)
 
         # need to change the above line to the following if supporting a batch size > 1 and resizing to the same size
@@ -136,7 +139,8 @@ class TFDetector:
         Runs the detector on an image.
 
         Args:
-            image (Image): the PIL Image object on which we should run the detector
+            image (Image): the PIL Image object (or numpy array) on which we should run the detector, with
+                EXIF rotation already handled.
             image_id (str): a path to identify the image; will be in the "file" field of the output object            
             detection_threshold (float): only detections above this threshold will be included in the return
                 value
@@ -166,6 +170,7 @@ class TFDetector:
         result = { 'file': image_id }
         
         try:
+            
             b_box, b_score, b_class = self._generate_detections_one_image(image)
 
             # our batch size is 1; need to loop the batch dim if supporting batch size > 1
@@ -190,6 +195,7 @@ class TFDetector:
             result['detections'] = detections_cur_image
 
         except Exception as e:
+            
             result['failure'] = FAILURE_INFER
             print('TFDetector: image {} failed during inference: {}'.format(image_id, str(e)))
 

megadetector/detection/video_utils.py

@@ -22,6 +22,7 @@ from functools import partial
 from inspect import signature
 
 from megadetector.utils import path_utils    
+from megadetector.utils.ct_utils import sort_list_of_dicts_by_key
 from megadetector.visualization import visualization_utils as vis_utils
 
 default_fourcc = 'h264'
@@ -88,14 +89,14 @@ def find_videos(dirname,
     else:
         files = glob.glob(os.path.join(dirname, '*.*'))
         
+    files = [fn for fn in files if os.path.isfile(fn)]
+    
     if return_relative_paths:
         files = [os.path.relpath(fn,dirname) for fn in files]
 
     if convert_slashes:
         files = [fn.replace('\\', '/') for fn in files]
     
-    files = [fn for fn in files if os.path.isfile(fn)]
-    
     return find_video_strings(files)
 
 
@@ -197,7 +198,7 @@ def _filename_to_frame_number(filename):
 def _add_frame_numbers_to_results(results):
     """
     Given the 'images' list from a set of MD results that was generated on video frames,
-    add a 'frame_number' field to each image.
+    add a 'frame_number' field to each image, and return the list, sorted by frame number.
     
     Args:
         results (list): list of image dicts        
@@ -208,8 +209,186 @@ def _add_frame_numbers_to_results(results):
         fn = im['file']
         frame_number = _filename_to_frame_number(fn)
         im['frame_number'] = frame_number
+        
+    results = sort_list_of_dicts_by_key(results,'frame_number')
+    return results
+    
+
+def run_callback_on_frames(input_video_file, 
+                           frame_callback,
+                           every_n_frames=None, 
+                           verbose=False, 
+                           frames_to_process=None,
+                           allow_empty_videos=False):
+    """
+    Calls the function frame_callback(np.array,image_id) on all (or selected) frames in
+    [input_video_file].
+    
+    Args:
+        input_video_file (str): video file to process
+        frame_callback (function): callback to run on frames, should take an np.array and a string and 
+            return a single value.  callback should expect PIL-formatted (RGB) images.
+        every_n_frames (int, optional): sample every Nth frame starting from the first frame;
+            if this is None or 1, every frame is processed. Mutually exclusive with
+            frames_to_process.
+        verbose (bool, optional): enable additional debug console output
+        frames_to_process (list of int, optional): process this specific set of frames;
+            mutually exclusive with every_n_frames.  If all values are beyond the length
+            of the video, no frames are extracted.  Can also be a single int, specifying
+            a single frame number.
+        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
+            frames (by default, this is an error).
+    
+    Returns:
+        dict: dict with keys 'frame_filenames' (list), 'frame_rate' (float), 'results' (list).
+        'frame_filenames' are synthetic filenames (e.g. frame000000.jpg); 'results' are
+        in the same format used in the 'images' array in the MD results format.
+    """
+    
+    assert os.path.isfile(input_video_file), 'File {} not found'.format(input_video_file)
+    
+    if isinstance(frames_to_process,int):
+        frames_to_process = [frames_to_process]
+        
+    if (frames_to_process is not None) and (every_n_frames is not None):
+        raise ValueError('frames_to_process and every_n_frames are mutually exclusive')
+    
+    vidcap = cv2.VideoCapture(input_video_file)
+    n_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_rate = vidcap.get(cv2.CAP_PROP_FPS)
+    
+    if verbose:
+        print('Video {} contains {} frames at {} Hz'.format(input_video_file,n_frames,frame_rate))
+
+    frame_filenames = []
+    results = []
+    
+    # frame_number = 0
+    for frame_number in range(0,n_frames):
+
+        success,image = vidcap.read()
+        
+        if not success:
+            assert image is None
+            if verbose:
+                print('Read terminating at frame {} of {}'.format(frame_number,n_frames))
+            break
+
+        if every_n_frames is not None:
+            if frame_number % every_n_frames != 0:
+                continue
+
+        if frames_to_process is not None:
+            if frame_number > max(frames_to_process):
+                break
+            if frame_number not in frames_to_process:
+                continue
+            
+        frame_filename_relative = _frame_number_to_filename(frame_number)        
+        frame_filenames.append(frame_filename_relative)
+        
+        image_np = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)        
+        frame_results = frame_callback(image_np,frame_filename_relative)
+        results.append(frame_results)
+            
+    # ...for each frame    
+    
+    if len(frame_filenames) == 0:
+        if allow_empty_videos:
+            print('Warning: found no frames in file {}'.format(input_video_file))
+        else:
+            raise Exception('Error: found no frames in file {}'.format(input_video_file))
+        
+    if verbose:
+        print('\nProcessed {} of {} frames for {}'.format(
+            len(frame_filenames),n_frames,input_video_file))
+
+    vidcap.release()    
+    to_return = {}
+    to_return['frame_filenames'] = frame_filenames
+    to_return['frame_rate'] = frame_rate
+    to_return['results'] = results
+    
+    return to_return
+
+# ...def run_callback_on_frames(...)
+
+
+def run_callback_on_frames_for_folder(input_video_folder, 
+                                      frame_callback,
+                                      every_n_frames=None, 
+                                      verbose=False,                                       
+                                      allow_empty_videos=False,
+                                      recursive=True):
+    """
+    Calls the function frame_callback(np.array,image_id) on all (or selected) frames in 
+    all videos in [input_video_folder].
+    
+    Args:
+        input_video_folder (str): video folder to process
+        frame_callback (function): callback to run on frames, should take an np.array and a string and 
+            return a single value.  callback should expect PIL-formatted (RGB) images.
+        every_n_frames (int, optional): sample every Nth frame starting from the first frame;
+            if this is None or 1, every frame is processed.
+        verbose (bool, optional): enable additional debug console output
+        allow_empty_videos (bool, optional): Just print a warning if a video appears to have no
+            frames (by default, this is an error).
+        recursive (bool, optional): recurse into [input_video_folder]
+    
+    Returns:
+        dict: dict with keys 'video_filenames' (list of str), 'frame_rates' (list of floats),
+        'results' (list of list of dicts). 'video_filenames' will contain *relative* filenames.
+    """
+    
+    to_return = {'video_filenames':[],'frame_rates':[],'results':[]}
+    
+    # Recursively enumerate video files
+    input_files_full_paths = find_videos(input_video_folder,
+                                         recursive=recursive,
+                                         convert_slashes=True,
+                                         return_relative_paths=False)
+    print('Found {} videos in folder {}'.format(len(input_files_full_paths),input_video_folder))
+    
+    if len(input_files_full_paths) == 0:
+        return to_return
+        
+    # Process each video
+    
+    # video_fn_abs = input_files_full_paths[0]
+    for video_fn_abs in tqdm(input_files_full_paths):
+        video_results = run_callback_on_frames(input_video_file=video_fn_abs,
+                                               frame_callback=frame_callback,
+                                               every_n_frames=every_n_frames, 
+                                               verbose=verbose, 
+                                               frames_to_process=None,
+                                               allow_empty_videos=allow_empty_videos)
+        
+        """
+        dict: dict with keys 'frame_filenames' (list), 'frame_rate' (float), 'results' (list).
+            'frame_filenames' are synthetic filenames (e.g. frame000000.jpg); 'results' are
+            in the same format used in the 'images' array in the MD results format.
+        """
+        video_filename_relative = os.path.relpath(video_fn_abs,input_video_folder)
+        video_filename_relative = video_filename_relative.replace('\\','/')
+        to_return['video_filenames'].append(video_filename_relative)
+        to_return['frame_rates'].append(video_results['frame_rate'])
+        for r in video_results['results']:
+            assert r['file'].startswith('frame')
+            r['file'] = video_filename_relative + '/' + r['file']
+        to_return['results'].append(video_results['results'])
+        
+    # ...for each video
+    
+    n_videos = len(input_files_full_paths)
+    assert len(to_return['video_filenames']) == n_videos
+    assert len(to_return['frame_rates']) == n_videos
+    assert len(to_return['results']) == n_videos
     
+    return to_return
 
+# ...def run_callback_on_frames_for_folder(...)
+
+    
 def video_to_frames(input_video_file, 
                     output_folder, 
                     overwrite=True, 
@@ -220,7 +399,7 @@ def video_to_frames(input_video_file,
                     frames_to_extract=None,
                     allow_empty_videos=False):
     """
-    Renders frames from [input_video_file] to a .jpg in [output_folder].
+    Renders frames from [input_video_file] to .jpg files in [output_folder].
     
     With help from:
         
@@ -341,7 +520,7 @@ def video_to_frames(input_video_file,
     # ...if we need to check whether to skip this video entirely
         
     if verbose:
-        print('Reading {} frames at {} Hz from {}'.format(n_frames,Fs,input_video_file))
+        print('Video {} contains {} frames at {} Hz'.format(input_video_file,n_frames,Fs))
 
     frame_filenames = []
 
@@ -410,8 +589,8 @@ def video_to_frames(input_video_file,
         
         # ...if we need to deal with resizing
         
-        frame_filename = _frame_number_to_filename(frame_number)
-        frame_filename = os.path.join(output_folder,frame_filename)
+        frame_filename_relative = _frame_number_to_filename(frame_number)        
+        frame_filename = os.path.join(output_folder,frame_filename_relative)
         frame_filenames.append(frame_filename)
         
         if overwrite == False and os.path.isfile(frame_filename):
@@ -441,9 +620,13 @@ def video_to_frames(input_video_file,
             except Exception as e:
                 print('Error on frame {} of {}: {}'.format(frame_number,n_frames,str(e)))
 
+    # ...for each frame
+    
     if len(frame_filenames) == 0:
-        raise Exception('Error: found no frames in file {}'.format(
-            input_video_file))
+        if allow_empty_videos:
+            print('Warning: found no frames in file {}'.format(input_video_file))
+        else:
+            raise Exception('Error: found no frames in file {}'.format(input_video_file))
         
     if verbose:
         print('\nExtracted {} of {} frames for {}'.format(
@@ -457,7 +640,7 @@ def video_to_frames(input_video_file,
 
 def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,
                                 every_n_frames,overwrite,verbose,quality,max_width,
-                                frames_to_extract):
+                                frames_to_extract,allow_empty_videos):
     """
     Internal function to call video_to_frames for a single video in the context of 
     video_folder_to_frames;  makes sure the right output folder exists, then calls 
@@ -474,10 +657,15 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,
 
     # Render frames
     # input_video_file = input_fn_absolute; output_folder = output_folder_video
-    frame_filenames,fs = video_to_frames(input_fn_absolute,output_folder_video,
-                                         overwrite=overwrite,every_n_frames=every_n_frames,
-                                         verbose=verbose,quality=quality,max_width=max_width,
-                                         frames_to_extract=frames_to_extract)
+    frame_filenames,fs = video_to_frames(input_fn_absolute,
+                                         output_folder_video,
+                                         overwrite=overwrite,
+                                         every_n_frames=every_n_frames,
+                                         verbose=verbose,
+                                         quality=quality,
+                                         max_width=max_width,
+                                         frames_to_extract=frames_to_extract,
+                                         allow_empty_videos=allow_empty_videos)
     
     return frame_filenames,fs
 
@@ -487,7 +675,7 @@ def video_folder_to_frames(input_folder, output_folder_base,
                            n_threads=1, every_n_frames=None,
                            verbose=False, parallelization_uses_threads=True,
                            quality=None, max_width=None, 
-                           frames_to_extract=None):
+                           frames_to_extract=None, allow_empty_videos=False):
     """
     For every video file in input_folder, creates a folder within output_folder_base, and 
     renders frame of that video to images in that folder.
@@ -545,7 +733,7 @@ def video_folder_to_frames(input_folder, output_folder_base,
             frame_filenames,fs = \
                 _video_to_frames_for_folder(input_fn_relative,input_folder,output_folder_base,
                                             every_n_frames,overwrite,verbose,quality,max_width,
-                                            frames_to_extract)
+                                            frames_to_extract,allow_empty_videos)
             frame_filenames_by_video.append(frame_filenames)
             fs_by_video.append(fs)
     else:
@@ -563,7 +751,8 @@ def video_folder_to_frames(input_folder, output_folder_base,
                                              verbose=verbose,
                                              quality=quality,
                                              max_width=max_width,
-                                             frames_to_extract=frames_to_extract)
+                                             frames_to_extract=frames_to_extract,
+                                             allow_empty_videos=allow_empty_videos)
         results = list(tqdm(pool.imap(
             partial(process_video_with_options),input_files_relative_paths), 
                             total=len(input_files_relative_paths)))
@@ -592,7 +781,8 @@ class FrameToVideoOptions:
         self.non_video_behavior = 'error'
     
 
-def frame_results_to_video_results(input_file,output_file,options=None):
+def frame_results_to_video_results(input_file,output_file,options=None,
+                                   video_filename_to_frame_rate=None):
     """
     Given an MD results file produced at the *frame* level, corresponding to a directory 
     created with video_folder_to_frames, maps those frame-level results back to the 
@@ -605,6 +795,8 @@ def frame_results_to_video_results(input_file,output_file,options=None):
         output_file (str): the .json file to which we should write video-level results
         options (FrameToVideoOptions, optional): parameters for converting frame-level results
             to video-level results, see FrameToVideoOptions for details            
+        video_filename_to_frame_rate (dict): maps (relative) video path names to frame rates,
+            used only to populate the output file
     """
 
     if options is None:
@@ -693,6 +885,10 @@ def frame_results_to_video_results(input_file,output_file,options=None):
         im_out['file'] = video_name
         im_out['detections'] = canonical_detections
         
+        if (video_filename_to_frame_rate is not None) and \
+            (video_name in video_filename_to_frame_rate):
+            im_out['frame_rate'] = video_filename_to_frame_rate[video_name]
+        
         # 'max_detection_conf' is no longer included in output files by default
         if False:
             im_out['max_detection_conf'] = 0