megadetector 5.0.21__py3-none-any.whl → 5.0.22__py3-none-any.whl

megadetector/postprocessing/detector_calibration.py

@@ -10,6 +10,7 @@ versions of MegaDetector.
 #%% Constants and imports
 
 import random
+import copy
 
 from tqdm import tqdm
 from enum import IntEnum
@@ -21,7 +22,7 @@ import matplotlib.pyplot as plt
 
 from megadetector.postprocessing.validate_batch_results import \
     validate_batch_results, ValidateBatchResultsOptions
-from megadetector.utils.ct_utils import get_iou
+from megadetector.utils.ct_utils import get_iou, max_none, is_iterable
 
 
 #%% Classes
@@ -36,7 +37,7 @@ class CalibrationOptions:
         #: IoU threshold used for determining whether two detections are the same
         #:
         #: When multiple detections match, we will only use the highest-matching IoU.
-        self.iou_threshold = 0.75
+        self.iou_threshold = 0.6
         
         #: Minimum confidence threshold to consider for calibration (should be lower than
         #: the lowest value you would use in realistic situations)
@@ -52,9 +53,18 @@ class CalibrationOptions:
         self.model_name_b = 'model_b'
         
         #: Maximum number of samples to use for plotting or calibration per category,
-        #: or None to use all paired values.
+        #: or None to use all paired values.  If separate_plots_by_category is False,
+        #: this is the overall number of points sampled.
         self.max_samples_per_category = None
         
+        #: Should we make separate plots for each category?  Mutually exclusive with
+        #: separate_plots_by_correctness.
+        self.separate_plots_by_category = True
+        
+        #: Should we make separate plots for TPs/FPs?  Mutually exclusive with
+        #: separate_plots_by_category.
+        self.separate_plots_by_correctness = False
+        
         #: List of category IDs to use for plotting comparisons, or None to plot
         #: all categories.
         self.categories_to_plot = None
@@ -62,15 +72,19 @@ class CalibrationOptions:
         #: Optionally map category ID to name in plot labels
         self.category_id_to_name = None
         
+        #: Enable additional debug output
+        self.verbose = True
+        
 # ...class CalibrationOptions
 
-class ConfidenceMatchColumns(IntEnum):
+class CalibrationMatchColumns(IntEnum):
     
     COLUMN_CONF_A = 0
     COLUMN_CONF_B = 1
-    COLUMN_CONF_IOU = 2
-    COLUMN_CONF_I_IMAGE = 3
-    COLUMN_CONF_CATEGORY_ID = 4
+    COLUMN_IOU = 2
+    COLUMN_I_IMAGE = 3
+    COLUMN_CATEGORY_ID = 4
+    COLUMN_MATCHES_GT = 5
     
 class CalibrationResults:
     """
@@ -79,8 +93,12 @@ class CalibrationResults:
         
     def __init__(self):
         
-        #: List of tuples: [conf_a, conf_b, iou, i_image, category_id]
-        self.confidence_matches = []
+        #: List of tuples: [conf_a, conf_b, iou, i_image, category_id, matches_gt]
+        #:
+        #: If ground truth is supplied, [matches_gt] is a bool indicating whether either
+        #: of the detected boxes matches a ground truth box of the same category.  If
+        #: ground truth is not supplied, [matches_gt] is None.
+        self.calibration_matches = []
         
         #: Populated with the data loaded from json_filename_a if options.return_data is True
         self.data_a = None
@@ -93,7 +111,7 @@ class CalibrationResults:
 
 #%% Calibration functions
 
-def compare_model_confidence_values(json_filename_a,json_filename_b,options=None):
+def compare_model_confidence_values(json_filename_a,json_filename_b,json_filename_gt=None,options=None):
     """
     Compare confidence values across two .json results files.  Compares only detections that
     can be matched by IoU, i.e., does not do anything with detections that only appear in one file.
@@ -103,6 +121,9 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
             should refer to the same images as [json_filename_b].  Can also be a loaded results dict.
         json_filename_b (str or dict): filename containing results from the second model to be compared; 
             should refer to the same images as [json_filename_a].  Can also be a loaded results dict.
+        json_filename_gt (str or dict, optional): filename containing ground truth; should refer to the 
+            same images as [json_filename_a] and [json_filename_b].  Can also be a loaded results dict.
+            Should be in COCO format.
         options (CalibrationOptions, optional): all the parameters used to control this process, see 
             CalibrationOptions for details
             
@@ -132,6 +153,16 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
         assert isinstance(json_filename_b,dict)
         results_b = json_filename_b
         
+    # Load ground truth, if supplied
+    gt_data = None
+    
+    if json_filename_gt is not None:
+        if isinstance(json_filename_gt,str):
+            gt_data = validate_batch_results(json_filename_gt,
+                                             options=validation_options)
+        else:
+            assert isinstance(json_filename_gt,dict)
+            gt_data = json_filename_gt
         
     ## Make sure these results sets are comparable
     
@@ -148,6 +179,32 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
         assert categories_a[k] == categories_b[k], 'Category mismatch'
     
     
+    ## Load ground truth if necessary
+    
+    gt_category_name_to_id = None
+    gt_image_id_to_annotations = None
+    image_filename_to_gt_im = None    
+    
+    if gt_data is not None:
+        
+        gt_category_name_to_id = {}
+        for c in gt_data['categories']:
+            gt_category_name_to_id[c['name']] = c['id']
+            
+        image_filename_to_gt_im = {}        
+        for im in gt_data['images']:
+            assert 'width' in im and 'height' in im, \
+                'I can only compare against GT that has "width" and "height" fields'                
+            image_filename_to_gt_im[im['file_name']] = im
+            
+        assert set(image_filename_to_gt_im.keys()) == set(image_filenames_a), \
+            'Ground truth filename list does not match image filename list'
+    
+        gt_image_id_to_annotations = defaultdict(list)
+        for ann in gt_data['annotations']:
+            gt_image_id_to_annotations[ann['image_id']].append(ann)
+            
+            
     ## Compare detections
     
     image_filename_b_to_im = {}
@@ -158,10 +215,10 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
     n_detections_a_queried = 0
     n_detections_a_matched = 0
     
-    confidence_matches = []
+    calibration_matches = []
     
     # For each image
-    # im_a = results_a['images'][0]
+    # im_a = results_a['images'][0]    
     for i_image,im_a in tqdm(enumerate(results_a['images']),total=len(results_a['images'])):
             
         fn = im_a['file']
@@ -172,6 +229,10 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
         if 'detections' not in im_b or im_b['detections'] is None:
             continue
     
+        im_gt = None
+        if gt_data is not None:
+            im_gt = image_filename_to_gt_im[fn]
+            
         # For each detection in result set A...
         #
         # det_a = im_a['detections'][0]
@@ -192,7 +253,8 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
             
             best_iou = None
             best_iou_conf = None
-                        
+            best_bbox_b = None
+            
             # For each detection in result set B...
             #
             # det_b = im_b['detections'][0]
@@ -220,24 +282,99 @@ def compare_model_confidence_values(json_filename_a,json_filename_b,options=None
                 if best_iou is None or iou > best_iou:
                     best_iou = iou
                     best_iou_conf = conf_b
+                    best_bbox_b = bbox_b
     
             # ...for each detection in im_b
         
+            # If we found a match between A and B
             if best_iou is not None:
+                
                 n_detections_a_matched += 1
-                conf_result = [conf_a,best_iou_conf,best_iou,i_image,category_id]
-                confidence_matches.append(conf_result)
+                
+                # Does this pair of matched detections also match a ground truth box?
+                matches_gt = None
         
+                if im_gt is not None:
+                
+                    def max_iou_between_detection_and_gt(detection_box,category_name,im_gt,gt_annotations):
+                    
+                        max_iou = None
+                        
+                        # Which category ID are we looking for?
+                        gt_category_id_for_detected_category_name = \
+                            gt_category_name_to_id[category_name]
+                        
+                        # For each GT annotation
+                        #
+                        # ann = gt_annotations[0]
+                        for ann in gt_annotations:
+                            
+                            # Only match against boxes in the same category
+                            if ann['category_id'] != gt_category_id_for_detected_category_name:
+                                continue
+                            if 'bbox' not in ann:
+                                continue
+                            
+                            # Normalize this box
+                            #
+                            # COCO format: [x,y,width,height]
+                            # normalized format: [x_min, y_min, width_of_box, height_of_box]        
+                            normalized_gt_box = [ann['bbox'][0]/im_gt['width'],ann['bbox'][1]/im_gt['height'],
+                                                 ann['bbox'][2]/im_gt['width'],ann['bbox'][3]/im_gt['height']]            
+                            
+                            iou = get_iou(detection_box, normalized_gt_box)
+                            if max_iou is None or iou > max_iou:
+                                max_iou = iou
+                        
+                        # ...for each gt box
+                        
+                        return max_iou
+                    
+                    # ...def min_iou_between_detections_and_gt(...)
+                    
+                    gt_annotations = gt_image_id_to_annotations[im_gt['id']]
+                    
+                    # If they matched, the A and B boxes have the same category by definition
+                    category_name = categories_a[det_a['category']]
+                    
+                    max_iou_with_bbox_a = max_iou_between_detection_and_gt(bbox_a,category_name,im_gt,gt_annotations)
+                    max_iou_with_bbox_b = max_iou_between_detection_and_gt(best_bbox_b,category_name,im_gt,gt_annotations)
+                    
+                    max_iou_with_either_detection_set = max_none(max_iou_with_bbox_a,
+                                                                 max_iou_with_bbox_b)
+                    
+                    matches_gt = False
+                    if (max_iou_with_either_detection_set is not None) and \
+                       (max_iou_with_either_detection_set >= options.iou_threshold):
+                        matches_gt = True                        
+                
+                # ...if we have ground truth
+                
+                conf_result = [conf_a,best_iou_conf,best_iou,i_image,category_id,matches_gt]
+                calibration_matches.append(conf_result)
+        
+            # ...if we had a match between A and B
         # ...for each detection in im_a
         
     # ...for each image in result set A
     
-    print('\nOf {} detections in result set A, queried {}, matched {}'.format(
-        n_detections_a,n_detections_a_queried,n_detections_a_matched))
-    assert len(confidence_matches) == n_detections_a_matched
+    if options.verbose:
+        
+        print('\nOf {} detections in result set A, queried {}, matched {}'.format(
+            n_detections_a,n_detections_a_queried,n_detections_a_matched))
+        
+        if gt_data is not None:
+            n_matches = 0
+            for m in calibration_matches:
+               assert m[CalibrationMatchColumns.COLUMN_MATCHES_GT] is not None
+               if m[CalibrationMatchColumns.COLUMN_MATCHES_GT]:
+                   n_matches += 1                   
+            print('{} matches also matched ground truth'.format(n_matches))            
+        
+    assert len(calibration_matches) == n_detections_a_matched
 
     calibration_results = CalibrationResults()        
-    calibration_results.confidence_matches = confidence_matches
+    calibration_results.calibration_matches = calibration_matches
 
     if options.return_data:
         calibration_results.data_a = results_a
@@ -272,31 +409,87 @@ def plot_matched_confidence_values(calibration_results,output_filename,options=N
     if options is None:
         options = CalibrationOptions()
     
-    # Find matched confidence pairs for each category ID
-    category_to_matches = defaultdict(list)
+    assert not (options.separate_plots_by_category and \
+                options.separate_plots_by_correctness), \
+        'separate_plots_by_category and separate_plots_by_correctness are mutually exclusive'
     
-    confidence_matches = calibration_results.confidence_matches
-    for m in confidence_matches:
-        category_id = m[ConfidenceMatchColumns.COLUMN_CONF_CATEGORY_ID]
-        category_to_matches[category_id].append(m)
+    category_id_to_name = None
+    category_to_samples = None
     
-    # Optionally sample matches
-    category_to_samples = defaultdict(list)
-           
-    for i_category,category_id in enumerate(category_to_matches.keys()):
+    calibration_matches = calibration_results.calibration_matches
+                
+    # If we're just lumping everything into one plot
+    if (not options.separate_plots_by_category) and (not options.separate_plots_by_correctness):
         
-        matches_this_category = category_to_matches[category_id]
+        category_id_to_name = {'0':'all_categories'}                
+        category_to_samples = {'0': []}
         
-        if (options.max_samples_per_category is None) or \
-            (len(matches_this_category) <= options.max_samples_per_category):
-            category_to_samples[category_id] = matches_this_category
-        else:
-            assert len(matches_this_category) > options.max_samples_per_category
-            category_to_samples[category_id] = random.sample(matches_this_category,options.max_samples_per_category)
+        # Make everything category "0" (arbitrary)
+        calibration_matches = copy.deepcopy(calibration_matches)
+        for m in calibration_matches:
+            m[CalibrationMatchColumns.COLUMN_CATEGORY_ID] = '0'
+        if (options.max_samples_per_category is not None) and \
+           (len(calibration_matches) > options.max_samples_per_category):
+            calibration_matches = \
+                random.sample(calibration_matches,options.max_samples_per_category)        
+        category_to_samples['0'] = calibration_matches
+    
+    # If we're separating into lines for FPs and TPs (but not separating by category)
+    elif options.separate_plots_by_correctness:
+        
+        assert not options.separate_plots_by_category
+        
+        category_id_tp = '0'
+        category_id_fp = '1'
+        
+        category_id_to_name = {category_id_tp:'TP', category_id_fp:'FP'}
+        category_to_samples = {category_id_tp: [], category_id_fp: []}
+        
+        for m in calibration_matches:
+            assert m[CalibrationMatchColumns.COLUMN_MATCHES_GT] is not None, \
+                "Can't plot by correctness when GT status is not available for every match"
+            if m[CalibrationMatchColumns.COLUMN_MATCHES_GT]:
+                category_to_samples[category_id_tp].append(m)
+            else:
+                category_to_samples[category_id_fp].append(m)
+    
+    # If we're separating by category
+    else:
+        
+        assert options.separate_plots_by_category
     
-    del category_to_matches
-    del confidence_matches
+        category_to_samples = defaultdict(list)        
+        
+        category_to_matches = defaultdict(list)    
+        for m in calibration_matches:    
+            category_id = m[CalibrationMatchColumns.COLUMN_CATEGORY_ID]
+            category_to_matches[category_id].append(m)
+        
+        category_id_to_name = None
+        if options.category_id_to_name is not None:
+            category_id_to_name = options.category_id_to_name
+            
+        for i_category,category_id in enumerate(category_to_matches.keys()):
+            
+            matches_this_category = category_to_matches[category_id]
+            
+            if (options.max_samples_per_category is None) or \
+                (len(matches_this_category) <= options.max_samples_per_category):
+                category_to_samples[category_id] = matches_this_category
+            else:
+                assert len(matches_this_category) > options.max_samples_per_category
+                category_to_samples[category_id] = random.sample(matches_this_category,options.max_samples_per_category)
+    
+        del category_to_matches
+        
+    del calibration_matches
     
+    if options.verbose:
+        n_samples_for_histogram = 0
+        for c in category_to_samples:
+            n_samples_for_histogram += len(category_to_samples[c])
+        print('Creating a histogram based on {} samples'.format(n_samples_for_histogram))
+        
     categories_to_plot = list(category_to_samples.keys())
     
     if options.categories_to_plot is not None:
@@ -311,16 +504,19 @@ def plot_matched_confidence_values(calibration_results,output_filename,options=N
     # fig,axes = plt.subplots(nrows=n_subplots,ncols=1)    
     
     axes = fig.subplots(n_subplots, 1)
+    
+    if not is_iterable(axes):
+        assert n_subplots == 1
+        axes = [axes]
 
     # i_category = 0; category_id = categories_to_plot[i_category]
     for i_category,category_id in enumerate(categories_to_plot):
     
         ax = axes[i_category]
         
-        category_string = category_id
-        if options.category_id_to_name is not None and \
-            category_id in options.category_id_to_name:
-            category_string = options.category_id_to_name[category_id]
+        category_string = str(category_id)
+        if (category_id_to_name is not None) and (category_id in category_id_to_name):
+            category_string = category_id_to_name[category_id]
             
         samples_this_category = category_to_samples[category_id]
         x = [m[0] for m in samples_this_category]
@@ -328,8 +524,11 @@ def plot_matched_confidence_values(calibration_results,output_filename,options=N
         
         weights_a = np.ones_like(x)/float(len(x))
         weights_b = np.ones_like(y)/float(len(y))
-        ax.hist(x,histtype='step',bins=n_hist_bins,density=False,color='red',weights=weights_a)
-        ax.hist(y,histtype='step',bins=n_hist_bins,density=False,color='blue',weights=weights_b)
+        
+        # Plot the first lie a little thicker so the second line will always show up
+        ax.hist(x,histtype='step',bins=n_hist_bins,density=False,color='red',weights=weights_a,linewidth=3.0)
+        ax.hist(y,histtype='step',bins=n_hist_bins,density=False,color='blue',weights=weights_b,linewidth=1.5)
+        
         ax.legend([options.model_name_a,options.model_name_b])
         ax.set_ylabel(category_string)
         # plt.tight_layout()
@@ -364,4 +563,3 @@ if False:
     options.relative_path_base = r'g:\temp\test-videos'
     validate_batch_results(json_filename,options)
     
-

megadetector/postprocessing/md_to_coco.py

@@ -3,7 +3,8 @@
 md_to_coco.py
 
 "Converts" MegaDetector output files to COCO format.  "Converts" is in quotes because
-this is an opinionated transformation that requires a confidence threshold.
+this is an opinionated transformation that requires a confidence threshold for most 
+applications.
 
 Does not currently handle classification information.
 
@@ -18,6 +19,7 @@ import uuid
 from tqdm import tqdm
 
 from megadetector.visualization import visualization_utils as vis_utils
+from megadetector.utils.path_utils import insert_before_extension
 
 default_confidence_threshold = 0.15
 
@@ -33,24 +35,29 @@ def md_to_coco(md_results_file,
                preserve_nonstandard_metadata=True,
                include_failed_images=True,
                include_annotations_without_bounding_boxes=True,
-               empty_category_id='0'):
+               empty_category_id='0',
+               overwrite_behavior='skip',               
+               verbose=True,
+               image_filename_to_size=None):
     """
     "Converts" MegaDetector output files to COCO format.  "Converts" is in quotes because
-    this is an opinionated transformation that requires a confidence threshold.
+    this is an opinionated transformation that typically 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 if 
-    preserve_nonstandard_metadata is True.
+    file to *evaluate* a detector, rather than as a set of labels, you likely want a 
+    confidence threshold of 0.  Confidence values will be written to the semi-standard "score" 
+    field for each image (regardless of the threshold) if preserve_nonstandard_metadata is True.
     
     A folder of images is required if width and height information are not available 
     in the MD results file.
 
     Args:
-        md_results_file (str): MD results .json file to convert to COCO format
+        md_results_file (str): MD results .json file to convert to COCO 
+            format
         coco_output_file (str, optional): COCO .json file to write; if this is None, we'll return 
-            a COCO-formatted dict, but won't write it to disk
+            a COCO-formatted dict, but won't write it to disk.  If this is 'auto', we'll write to
+            [md_results_file_without_extension].coco.json.
         image_folder (str, optional): folder of images, required if 'width' and 'height' are not
             present in the MD results file (they are not required by the format)
         confidence_threshold (float, optional): boxes below this confidence threshold will not be
@@ -60,8 +67,8 @@ def md_to_coco(md_results_file,
         info (dict, optional): arbitrary metadata to include in an "info" field in the COCO-formatted
             output
         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    
+            non-standard "score" 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 (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
@@ -69,22 +76,62 @@ def md_to_coco(md_results_file,
             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
+        overwrite_behavior (str, optional): determines behavior if the output file exists ('skip' to skip conversion,
+            'overwrite' to overwrite the existing file, 'error' to raise an error, 'skip_if_valid' to skip conversion
+            if the .json file appears to be intact (does not verify COCO formatting, just intact-.json-ness))
+        verbose (bool, optional): enable debug output, including the progress bar,
+        image_filename_to_size (dict, optional): dictionary mapping relative image paths to (w,h) tuples.  Reading
+            image sizes is the slowest step, so if you need to convert many results files at once for the same
+            set of images, things will be gobs faster if you read the image sizes in advance and pass them in
+            via this argument.  The format used here is the same format output by parallel_get_image_sizes().
     
     Returns:
         dict: the COCO data dict, identical to what's written to [coco_output_file] if [coco_output_file]
         is not None.
     """
+    
+    assert isinstance(md_results_file,str)
+    assert os.path.isfile(md_results_file), \
+        'MD results file {} does not exist'.format(md_results_file)
 
+    if coco_output_file == 'auto':
+        coco_output_file = insert_before_extension(md_results_file,'coco')
+        
+    if coco_output_file is not None:
+        if os.path.isfile(coco_output_file):
+            if overwrite_behavior == 'skip':
+                print('Skipping conversion of {}, output file {} exists'.format(
+                    md_results_file,coco_output_file))
+                return None
+            elif overwrite_behavior == 'skip_if_valid':
+                output_file_is_valid = True
+                try:
+                    with open(coco_output_file,'r') as f:
+                        _ = json.load(f)
+                except Exception:
+                    print('COCO file {} is invalid, proceeding with conversion'.format(
+                        coco_output_file))
+                    output_file_is_valid = False
+                if output_file_is_valid:
+                    print('Skipping conversion of {}, output file {} exists and is valid'.format(
+                        md_results_file,coco_output_file))
+                    return None
+            elif overwrite_behavior == 'overwrite':
+                pass
+            elif overwrite_behavior == 'error':
+                raise ValueError('Output file {} exists'.format(coco_output_file))
+            
     with open(md_results_file,'r') as f:    
         md_results = json.load(f)    
         
     coco_images = []
     coco_annotations = []
         
-    print('Converting MD results to COCO...')
+    print('Converting MD results file {} to COCO file {}...'.format(
+        md_results_file, coco_output_file))
     
     # im = md_results['images'][0]
-    for im in tqdm(md_results['images']):
+    for im in tqdm(md_results['images'],disable=(not verbose)):
         
         coco_im = {}
         coco_im['id'] = im['file']
@@ -102,18 +149,36 @@ def md_to_coco(md_results_file,
         h = None
         
         if ('width' not in im) or ('height' not in im) or validate_image_sizes:
-            if image_folder is None:
-                raise ValueError('Must provide an image folder when height/width need to be read from images')
-            image_file_abs = os.path.join(image_folder,im['file'])
-            pil_im = vis_utils.open_image(image_file_abs)
-            w = pil_im.width
-            h = pil_im.height
+            if (image_folder is None) and (image_filename_to_size is None):
+                raise ValueError('Must provide an image folder or a size mapping when height/width need to be read from images')
+                
+            w = None; h = None
+            
+            if image_filename_to_size is not None:
+                
+                if im['file'] not in image_filename_to_size:
+                    print('Warning: file {} not in image size mapping dict, reading from file'.format(im['file']))
+                else:
+                    image_size = image_filename_to_size[im['file']]
+                    if image_size is not None:
+                        assert len(image_size) == 2
+                        w = image_size[0]
+                        h = image_size[1]
+            
+            if w is None:
+                
+                image_file_abs = os.path.join(image_folder,im['file'])
+                pil_im = vis_utils.open_image(image_file_abs)
+                w = pil_im.width
+                h = pil_im.height
+                        
             if validate_image_sizes:
                 if 'width' in im:
                     assert im['width'] == w, 'Width mismatch for image {}'.format(im['file'])
                 if 'height' in im:
                     assert im['height'] == h, 'Height mismatch for image {}'.format(im['file'])
         else:
+            
             w = im['width']
             h = im['height']
             
@@ -203,9 +268,9 @@ def md_to_coco(md_results_file,
         with open(coco_output_file,'w') as f:
             json.dump(output_dict,f,indent=1)
     
-    return output_dict
+    return output_dict    
 
-# def md_to_coco(...)
+# ...def md_to_coco(...)
 
 
 #%% Interactive driver

megadetector/postprocessing/postprocess_batch_results.py

@@ -898,7 +898,6 @@ def _render_image_with_gt(file_info,ground_truth_indexed_db,
 #%% Main function
 
 def process_batch_results(options):
-
     """
     Given a .json or .csv file containing MD results, do one or more of the following: