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

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

@@ -88,14 +88,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)
 
 
@@ -210,6 +210,181 @@ def _add_frame_numbers_to_results(results):
         im['frame_number'] = frame_number
     
 
+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), 'frame_rates' (list of floats), 'results' (list).
+        video_filenames will be *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 +395,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 +516,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 +585,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 +616,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 +636,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 +653,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 +671,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 +729,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 +747,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)))

megadetector/postprocessing/md_to_coco.py

@@ -31,11 +31,18 @@ def md_to_coco(md_results_file,
                validate_image_sizes=False,
                info=None,
                preserve_nonstandard_metadata=True,
-               include_failed_images=True):
+               include_failed_images=True,
+               include_annotations_without_bounding_boxes=True,
+               empty_category_id='0'):
     """
     "Converts" MegaDetector output files to COCO format.  "Converts" is in quotes because
     this is an opinionated transformation that requires a confidence threshold.
     
+    The default confidence threshold is not 0; the assumption is that by default, you are 
+    going to treat the resulting COCO file as a set of labels.  If you are using the resulting COCO
+    file to evaluate a detector, you likely want a default confidence threshold of 0.  Confidence
+    values will be written to the semi-standard "score" field for each image
+    
     A folder of images is required if width and height information are not available 
     in the MD results file.
 
@@ -54,8 +61,13 @@ def md_to_coco(md_results_file,
         preserve_nonstandard_metadata (bool, optional): if this is True, confidence will be preserved in a 
             non-standard "conf" field in each annotation, and any random fields present in each image's data
             (e.g. EXIF metadata) will be propagated to COCO output    
-        include_failed_images (boo, optional): if this is True, failed images will be propagated to COCO output 
+        include_failed_images (bool, optional): if this is True, failed images will be propagated to COCO output 
             with a non-empty "failure" field and no other fields, otherwise failed images will be skipped.
+        include_annotations_without_bounding_boxes (bool, optional): if this is True, annotations with
+            only class labels (no bounding boxes) will be included in the output.  If this is False, empty
+            images will be represented with no annotations.
+        empty_category_id (str, optional): category ID reserved for the 'empty' class, should not be
+            attached to any bounding boxes
     
     Returns:
         dict: the COCO data dict, identical to what's written to [coco_output_file] if [coco_output_file]
@@ -67,6 +79,8 @@ def md_to_coco(md_results_file,
         
     coco_images = []
     coco_annotations = []
+        
+    print('Converting MD results to COCO...')
     
     # im = md_results['images'][0]
     for im in tqdm(md_results['images']):
@@ -129,13 +143,13 @@ def md_to_coco(md_results_file,
             coco_category_id = int(md_category_id)
             ann['category_id'] = coco_category_id
             
-            # In very esoteric cases, we use the empty category (0) in MD-formatted output files
-            if md_category_id != '0':
+            if md_category_id != empty_category_id:
                 
                 assert 'bbox' in detection,\
                     'Oops: non-empty category with no bbox in {}'.format(im['file'])
             
                 ann['bbox'] = detection['bbox']
+                
                 # MegaDetector: [x,y,width,height] (normalized, origin upper-left)
                 # COCO: [x,y,width,height] (absolute, origin upper-left)
                 ann['bbox'][0] = ann['bbox'][0] * coco_im['width']
@@ -144,13 +158,19 @@ def md_to_coco(md_results_file,
                 ann['bbox'][3] = ann['bbox'][3] * coco_im['height']                
             
             else:
-                
-                print('Warning: empty category annotation in file {}'.format(im['file']))
+            
+                # In very esoteric cases, we use the empty category (0) in MD-formatted output files
+                print('Warning: empty category ({}) used for annotation in file {}'.format(
+                    empty_category_id,im['file']))
+                pass
                       
             if preserve_nonstandard_metadata:
-                ann['conf'] = detection['conf']
-                
-            coco_annotations.append(ann)            
+                # "Score" is a semi-standard string here, recognized by at least pycocotools
+                # ann['conf'] = detection['conf']
+                ann['score'] = detection['conf']
+        
+            if 'bbox' in ann or include_annotations_without_bounding_boxes:
+                coco_annotations.append(ann)            
         
         # ...for each detection
     
@@ -176,6 +196,8 @@ def md_to_coco(md_results_file,
                          'name':md_results['detection_categories'][md_category_id]}
         output_dict['categories'].append(coco_category)
         
+    print('Writing COCO output file...')
+    
     if coco_output_file is not None:
         with open(coco_output_file,'w') as f:
             json.dump(output_dict,f,indent=1)

megadetector/postprocessing/postprocess_batch_results.py

@@ -949,6 +949,13 @@ def process_batch_results(options):
               f'negative, {n_positive} positive, {n_unknown} unknown, '
               f'{n_ambiguous} ambiguous')
 
+        if n_positive == 0:
+            print('\n*** Warning: no positives found in ground truth, analysis won\'t be very meaningful ***\n')
+        if n_negative == 0:
+            print('\n*** Warning: no negatives found in ground truth, analysis won\'t be very meaningful ***\n')
+        if n_ambiguous > 0:
+            print('\n*** Warning: {} images with ambiguous positive/negative status found in ground truth ***\n'.format(
+                n_ambiguous))
 
     ##%% Load detection (and possibly classification) results
 
@@ -1095,25 +1102,34 @@ def process_batch_results(options):
 
         ##%% Detection evaluation: compute precision/recall
 
-        # numpy array of detection probabilities
+        # numpy array of maximum confidence values
         p_detection = detections_df['max_detection_conf'].values
-        n_detections = len(p_detection)
+        n_detection_values = len(p_detection)
 
         # numpy array of bools (0.0/1.0), and -1 as null value
-        gt_detections = np.zeros(n_detections, dtype=float)
+        gt_detections = np.zeros(n_detection_values, dtype=float)
 
+        n_positive = 0
+        n_negative = 0
+        
         for i_detection, fn in enumerate(detector_files):
+            
             image_id = ground_truth_indexed_db.filename_to_id[fn]
             image = ground_truth_indexed_db.image_id_to_image[image_id]
             detection_status = image['_detection_status']
 
             if detection_status == DetectionStatus.DS_NEGATIVE:
                 gt_detections[i_detection] = 0.0
+                n_negative += 1
             elif detection_status == DetectionStatus.DS_POSITIVE:
                 gt_detections[i_detection] = 1.0
+                n_positive += 1
             else:
                 gt_detections[i_detection] = -1.0
 
+        print('Of {} ground truth values, found {} positives and {} negatives'.format(
+            len(detections_df),n_positive,n_negative))
+        
         # Don't include ambiguous/unknown ground truth in precision/recall analysis
         b_valid_ground_truth = gt_detections >= 0.0