megadetector 10.0.10__py3-none-any.whl → 10.0.11__py3-none-any.whl

megadetector/detection/run_detector.py

@@ -13,8 +13,7 @@ check out run_detector_batch.py**.
 That said, this script (run_detector.py) is a good way to test our detector on a handful of images
 and get super-satisfying, graphical results.
 
-If you would like to *not* use the GPU on the machine, set the environment
-variable CUDA_VISIBLE_DEVICES to "-1".
+If you would like to *not* use the GPU, set the environment variable CUDA_VISIBLE_DEVICES to "-1".
 
 This script will only consider detections with > 0.005 confidence at all times.
 The threshold you provide is only for rendering the results. If you need to
@@ -79,6 +78,10 @@ DEFAULT_DETECTOR_LABEL_MAP = {
 # models other than MegaDetector.
 USE_MODEL_NATIVE_CLASSES = False
 
+# Detection threshold to recommend to callers when all other mechanisms for choosing
+# a model-specific threshold fail
+fallback_detection_threshold = 0.2
+
 # Maps a variety of strings that might occur in filenames to canonical version numbers.
 #
 # Order matters here.
@@ -215,7 +218,8 @@ known_models = {
     {
         'url':model_url_base + 'md_v1000.0.0-redwood.pt',
         'normalized_typical_inference_speed':1.0,
-        'md5':'74474b3aec9cf1a990da38b37ddf9197'
+        'md5':'74474b3aec9cf1a990da38b37ddf9197',
+        'typical_detection_threshold':0.3
     },
     'v1000.0.0-spruce':
     {
@@ -515,19 +519,34 @@ def get_typical_confidence_threshold_from_results(results):
         with open(results,'r') as f:
             results = json.load(f)
 
+    default_threshold = None
+
+    # Best case: the .json file tells us the default threshold
     if 'detector_metadata' in results['info'] and \
         'typical_detection_threshold' in results['info']['detector_metadata']:
         default_threshold = results['info']['detector_metadata']['typical_detection_threshold']
+    # Worst case: we don't even know what detector this is
     elif ('detector' not in results['info']) or (results['info']['detector'] is None):
         print('Warning: detector version not available in results file, using MDv5 defaults')
         detector_metadata = get_detector_metadata_from_version_string('v5a.0.0')
         default_threshold = detector_metadata['typical_detection_threshold']
+    # We know what detector this is, but it doesn't have a default threshold
+    # in the .json file
     else:
         print('Warning: detector metadata not available in results file, inferring from MD version')
-        detector_filename = results['info']['detector']
-        detector_version = get_detector_version_from_filename(detector_filename)
-        detector_metadata = get_detector_metadata_from_version_string(detector_version)
-        default_threshold = detector_metadata['typical_detection_threshold']
+        try:
+            detector_filename = results['info']['detector']
+            detector_version = get_detector_version_from_filename(detector_filename)
+            detector_metadata = get_detector_metadata_from_version_string(detector_version)
+            if 'typical_detection_threshold' in detector_metadata:
+                default_threshold = detector_metadata['typical_detection_threshold']
+        except Exception:
+            pass
+
+    if default_threshold is None:
+        print('Could not determine threshold, using fallback threshold of {}'.format(
+            fallback_detection_threshold))
+        default_threshold = fallback_detection_threshold
 
     return default_threshold
 
@@ -546,7 +565,7 @@ def is_gpu_available(model_file):
     """
 
     if model_file.endswith('.pb'):
-        import tensorflow.compat.v1 as tf
+        import tensorflow.compat.v1 as tf # type: ignore
         gpu_available = tf.test.is_gpu_available()
         print('TensorFlow version:', tf.__version__)
         print('tf.test.is_gpu_available:', gpu_available)
@@ -741,8 +760,9 @@ def load_and_run_detector(model_file,
         fn = '{}{}{}'.format(name, DETECTION_FILENAME_INSERT, '.jpg')
         if fn in output_filename_collision_counts:
             n_collisions = output_filename_collision_counts[fn]
+            fn_original = fn
             fn = '{:0>4d}'.format(n_collisions) + '_' + fn
-            output_filename_collision_counts[fn] += 1
+            output_filename_collision_counts[fn_original] += 1
         else:
             output_filename_collision_counts[fn] = 0
         fn = os.path.join(output_dir, fn)
@@ -847,7 +867,11 @@ def _validate_zip_file(file_path, file_description='file'):
     """
     try:
         with zipfile.ZipFile(file_path, 'r') as zipf:
-            zipf.testzip()
+            corrupt_file = zipf.testzip()
+            if corrupt_file is not None:
+                print('{} {} contains at least one corrupt file: {}'.format(
+                    file_description.capitalize(), file_path, corrupt_file))
+                return False
         return True
     except (zipfile.BadZipFile, zipfile.LargeZipFile) as e:
         print('{} {} appears to be corrupted (bad zip): {}'.format(

megadetector/detection/run_detector_batch.py

@@ -887,7 +887,7 @@ def _process_images(im_files,
 
     if use_image_queue:
 
-        _run_detector_with_image_queue(im_files,
+        results = _run_detector_with_image_queue(im_files,
                                       detector,
                                       confidence_threshold,
                                       quiet=quiet,
@@ -899,6 +899,7 @@ def _process_images(im_files,
                                       detector_options=detector_options,
                                       loader_workers=loader_workers,
                                       preprocess_on_image_queue=preprocess_on_image_queue)
+        return results
 
     else:
 

megadetector/detection/run_inference_with_yolov5_val.py

@@ -351,7 +351,9 @@ def run_inference_with_yolo_val(options):
         else:
             raise ValueError('Unknown output handling method {}'.format(options.overwrite_handling))
 
-    os.makedirs(os.path.dirname(options.output_file),exist_ok=True)
+    output_dir = os.path.dirname(options.output_file)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir, exist_ok=True)
 
     if options.input_folder is not None:
         options.input_folder = options.input_folder.replace('\\','/')

megadetector/detection/run_md_and_speciesnet.py

@@ -32,6 +32,7 @@ from megadetector.utils.ct_utils import write_json
 from megadetector.utils.ct_utils import make_temp_folder
 from megadetector.utils.ct_utils import is_list_sorted
 from megadetector.utils.ct_utils import is_sphinx_build
+from megadetector.utils.ct_utils import args_to_object
 from megadetector.utils import path_utils
 from megadetector.visualization import visualization_utils as vis_utils
 from megadetector.postprocessing.validate_batch_results import \
@@ -62,18 +63,20 @@ DEFAULT_DETECTOR_BATCH_SIZE = 1
 DEFAULT_CLASSIFIER_BATCH_SIZE = 8
 DEFAULT_LOADER_WORKERS = 4
 
-# This determines the maximum number of images that can get read from disk
-# on each of the producer workers before blocking.  The actual size of the queue
+# This determines the maximum number of image filenames that can be assigned to
+# each of the producer workers before blocking.  The actual size of the queue
 # will be MAX_IMAGE_QUEUE_SIZE_PER_WORKER * n_workers.  This is only used for
 # the classification step.
-MAX_IMAGE_QUEUE_SIZE_PER_WORKER = 10
+MAX_IMAGE_QUEUE_SIZE_PER_WORKER = 30
 
 # This determines the maximum number of crops that can accumulate in the queue
 # used to communicate between the producers (which read and crop images) and the
 # consumer (which runs the classifier).  This is only used for the classification step.
 MAX_BATCH_QUEUE_SIZE = 300
 
-DEAFULT_SECONDS_PER_VIDEO_FRAME = 1.0
+# Default interval between frames we should process when processing video.
+# This is only used for the detection step.
+DEFAULT_SECONDS_PER_VIDEO_FRAME = 1.0
 
 # Max number of classification scores to include per detection
 DEFAULT_TOP_N_SCORES = 2
@@ -168,6 +171,12 @@ def _process_image_detections(file_path: str,
 
     detections = detection_results['detections']
 
+    # Don't bother loading images that have no above-threshold detections
+    detections_above_threshold = \
+        [d for d in detections if d['conf'] >= detection_confidence_threshold]
+    if len(detections_above_threshold) == 0:
+        return
+
     # Load the image
     try:
         image = vis_utils.load_image(absolute_file_path)
@@ -189,6 +198,11 @@ def _process_image_detections(file_path: str,
         return
 
     # Process each detection above threshold
+    #
+    # detection_index needs to index into the original list of detections
+    # (this is how classification results will be associated with detections
+    # later), so iterate over "detections" here, rather than
+    # "detections_above_threshold".
     for detection_index, detection in enumerate(detections):
 
         conf = detection['conf']
@@ -562,7 +576,7 @@ def _crop_consumer_func(batch_queue: Queue,
     taxonomy_map = {}
     geofence_map = {}
 
-    if (enable_rollup is not None) or (country is not None):
+    if (enable_rollup) or (country is not None):
 
         # Note to self: there are a number of reasons loading the ensemble
         # could fail here; don't catch this exception, this should be a
@@ -1146,7 +1160,7 @@ def _run_classification_step(detector_results_file: str,
 
                     # Add classifications to the detection
                     detection['classifications'] = classification_pairs
-                    detection['raw_classifications'] = raw_classification_pairs
+                    # detection['raw_classifications'] = raw_classification_pairs
 
                 # ...if this classification contains a failure
 
@@ -1181,6 +1195,196 @@ def _run_classification_step(detector_results_file: str,
 # ...def _run_classification_step(...)
 
 
+#%% Options class
+
+class RunMDSpeciesNetOptions:
+    """
+    Class controlling the behavior of run_md_and_speciesnet()
+    """
+
+    def __init__(self):
+
+        #: Folder containing images and/or videos to process
+        self.source = None
+
+        #: Output file for results (JSON format)
+        self.output_file = None
+
+        #: MegaDetector model identifier (MDv5a, MDv5b, MDv1000-redwood, etc.)
+        self.detector_model = DEFAULT_DETECTOR_MODEL
+
+        #: SpeciesNet classifier model identifier (e.g. kaggle:google/speciesnet/pyTorch/v4.0.1a)
+        self.classification_model = DEFAULT_CLASSIFIER_MODEL
+
+        #: Batch size for MegaDetector inference
+        self.detector_batch_size = DEFAULT_DETECTOR_BATCH_SIZE
+
+        #: Batch size for SpeciesNet classification
+        self.classifier_batch_size = DEFAULT_CLASSIFIER_BATCH_SIZE
+
+        #: Number of worker threads for preprocessing
+        self.loader_workers = DEFAULT_LOADER_WORKERS
+
+        #: Classify detections above this threshold
+        self.detection_confidence_threshold_for_classification = \
+            DEFAULT_DETECTION_CONFIDENCE_THRESHOLD_FOR_CLASSIFICATION
+
+        #: Include detections above this threshold in the output
+        self.detection_confidence_threshold_for_output = \
+            DEFAULT_DETECTION_CONFIDENCE_THRESHOLD_FOR_OUTPUT
+
+        #: Folder for intermediate files (default: system temp)
+        self.intermediate_file_folder = None
+
+        #: Keep intermediate files (e.g. detection-only results file)
+        self.keep_intermediate_files = False
+
+        #: Disable taxonomic rollup
+        self.norollup = False
+
+        #: Country code (ISO 3166-1 alpha-3) for geofencing (default None, no geoferencing)
+        self.country = None
+
+        #: Admin1 region/state code for geofencing
+        self.admin1_region = None
+
+        #: Path to existing MegaDetector output file (skips detection step)
+        self.detections_file = None
+
+        #: Ignore videos, only process images
+        self.skip_video = False
+
+        #: Ignore images, only process videos
+        self.skip_images = False
+
+        #: Sample every Nth frame from videos
+        #:
+        #: Mutually exclusive with time_sample
+        self.frame_sample = None
+
+        #: Sample frames every N seconds from videos
+        #:
+        #: Mutually exclusive with frame_sample
+        self.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+        #: Enable additional debug output
+        self.verbose = False
+
+        if self.time_sample is None and self.frame_sample is None:
+            self.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+# ...class RunMDSpeciesNetOptions
+
+
+#%% Main function
+
+def run_md_and_speciesnet(options):
+    """
+    Main entry point, runs MegaDetector and SpeciesNet on a folder.  See
+    RunMDSpeciesNetOptions for available arguments.
+
+    Args:
+        options (RunMDSpeciesNetOptions): options controlling MD and SN inference
+    """
+
+    # Set global verbose flag
+    global verbose
+    verbose = options.verbose
+
+    # Also set the run_detector_batch verbose flag
+    run_detector_batch.verbose = verbose
+
+    # Validate arguments
+    if not os.path.isdir(options.source):
+        raise ValueError(
+            'Source folder does not exist: {}'.format(options.source))
+
+    if (options.admin1_region is not None) and (options.country is None):
+        raise ValueError('--admin1_region requires --country to be specified')
+
+    if options.skip_images and options.skip_video:
+        raise ValueError('Cannot skip both images and videos')
+
+    if (options.frame_sample is not None) and (options.time_sample is not None):
+        raise ValueError('--frame_sample and --time_sample are mutually exclusive')
+    if (options.frame_sample is None) and (options.time_sample is None):
+        options.time_sample = DEFAULT_SECONDS_PER_VIDEO_FRAME
+
+    # Set up intermediate file folder
+    if options.intermediate_file_folder:
+        temp_folder = options.intermediate_file_folder
+        os.makedirs(temp_folder, exist_ok=True)
+    else:
+        temp_folder = make_temp_folder(subfolder='run_md_and_speciesnet')
+
+    start_time = time.time()
+
+    print('Processing folder: {}'.format(options.source))
+    print('Output file: {}'.format(options.output_file))
+    print('Intermediate files: {}'.format(temp_folder))
+
+    # Determine detector output file path
+    if options.detections_file is not None:
+        detector_output_file = options.detections_file
+        if VALIDATE_DETECTION_FILE:
+            print('Using existing detections file: {}'.format(detector_output_file))
+            validation_options = ValidateBatchResultsOptions()
+            validation_options.check_image_existence = True
+            validation_options.relative_path_base = options.source
+            validation_options.raise_errors = True
+            validate_batch_results(detector_output_file,options=validation_options)
+            print('Validated detections file')
+        else:
+            print('Bypassing validation of {}'.format(options.detections_file))
+    else:
+        detector_output_file = os.path.join(temp_folder, 'detector_output.json')
+
+        # Run MegaDetector
+        _run_detection_step(
+            source_folder=options.source,
+            detector_output_file=detector_output_file,
+            detector_model=options.detector_model,
+            detector_batch_size=options.detector_batch_size,
+            detection_confidence_threshold=options.detection_confidence_threshold_for_output,
+            detector_worker_threads=options.loader_workers,
+            skip_images=options.skip_images,
+            skip_video=options.skip_video,
+            frame_sample=options.frame_sample,
+            time_sample=options.time_sample
+        )
+
+    # Run SpeciesNet
+    _run_classification_step(
+        detector_results_file=detector_output_file,
+        merged_results_file=options.output_file,
+        source_folder=options.source,
+        classifier_model=options.classification_model,
+        classifier_batch_size=options.classifier_batch_size,
+        classifier_worker_threads=options.loader_workers,
+        detection_confidence_threshold=options.detection_confidence_threshold_for_classification,
+        enable_rollup=(not options.norollup),
+        country=options.country,
+        admin1_region=options.admin1_region,
+    )
+
+    elapsed_time = time.time() - start_time
+    print(
+        'Processing complete in {}'.format(humanfriendly.format_timespan(elapsed_time)))
+    print('Results written to: {}'.format(options.output_file))
+
+    # Clean up intermediate files if requested
+    if (not options.keep_intermediate_files) and \
+       (not options.intermediate_file_folder) and \
+       (not options.detections_file):
+        try:
+            os.remove(detector_output_file)
+        except Exception as e:
+            print('Warning: error removing temporary output file {}: {}'.format(
+                detector_output_file, str(e)))
+
+# ...def run_md_and_speciesnet(...)
+
+
 #%% Command-line driver
 
 def main():
@@ -1236,7 +1440,7 @@ def main():
                         help='Folder for intermediate files (default: system temp)')
     parser.add_argument('--keep_intermediate_files',
                         action='store_true',
-                        help='Keep intermediate files for debugging')
+                        help='Keep intermediate files (e.g. detection-only results file)')
     parser.add_argument('--norollup',
                         action='store_true',
                         help='Disable taxonomic rollup')
@@ -1263,7 +1467,7 @@ def main():
                         type=float,
                         default=None,
                         help='Sample frames every N seconds from videos (default {})'.\
-                            format(DEAFULT_SECONDS_PER_VIDEO_FRAME) + \
+                            format(DEFAULT_SECONDS_PER_VIDEO_FRAME) + \
                             ' (mutually exclusive with --frame_sample)')
     parser.add_argument('--verbose',
                         action='store_true',
@@ -1275,100 +1479,10 @@ def main():
 
     args = parser.parse_args()
 
-    # Set global verbose flag
-    global verbose
-    verbose = args.verbose
-
-    # Also set the run_detector_batch verbose flag
-    run_detector_batch.verbose = verbose
-
-    # Validate arguments
-    if not os.path.isdir(args.source):
-        raise ValueError(
-            'Source folder does not exist: {}'.format(args.source))
-
-    if args.admin1_region and not args.country:
-        raise ValueError('--admin1_region requires --country to be specified')
-
-    if args.skip_images and args.skip_video:
-        raise ValueError('Cannot skip both images and videos')
-
-    if (args.frame_sample is not None) and (args.time_sample is not None):
-        raise ValueError('--frame_sample and --time_sample are mutually exclusive')
-    if (args.frame_sample is None) and (args.time_sample is None):
-        args.time_sample = DEAFULT_SECONDS_PER_VIDEO_FRAME
-
-    # Set up intermediate file folder
-    if args.intermediate_file_folder:
-        temp_folder = args.intermediate_file_folder
-        os.makedirs(temp_folder, exist_ok=True)
-    else:
-        temp_folder = make_temp_folder(subfolder='run_md_and_speciesnet')
-
-    start_time = time.time()
-
-    print('Processing folder: {}'.format(args.source))
-    print('Output file: {}'.format(args.output_file))
-    print('Intermediate files: {}'.format(temp_folder))
-
-    # Determine detector output file path
-    if args.detections_file is not None:
-        detector_output_file = args.detections_file
-        if VALIDATE_DETECTION_FILE:
-            print('Using existing detections file: {}'.format(detector_output_file))
-            validation_options = ValidateBatchResultsOptions()
-            validation_options.check_image_existence = True
-            validation_options.relative_path_base = args.source
-            validation_options.raise_errors = True
-            validate_batch_results(detector_output_file,options=validation_options)
-            print('Validated detections file')
-        else:
-            print('Bypassing validation of {}'.format(args.detections_file))
-    else:
-        detector_output_file = os.path.join(temp_folder, 'detector_output.json')
-
-        # Run MegaDetector
-        _run_detection_step(
-            source_folder=args.source,
-            detector_output_file=detector_output_file,
-            detector_model=args.detector_model,
-            detector_batch_size=args.detector_batch_size,
-            detection_confidence_threshold=args.detection_confidence_threshold_for_output,
-            detector_worker_threads=args.loader_workers,
-            skip_images=args.skip_images,
-            skip_video=args.skip_video,
-            frame_sample=args.frame_sample,
-            time_sample=args.time_sample
-        )
-
-    # Run SpeciesNet
-    _run_classification_step(
-        detector_results_file=detector_output_file,
-        merged_results_file=args.output_file,
-        source_folder=args.source,
-        classifier_model=args.classification_model,
-        classifier_batch_size=args.classifier_batch_size,
-        classifier_worker_threads=args.loader_workers,
-        detection_confidence_threshold=args.detection_confidence_threshold_for_classification,
-        enable_rollup=(not args.norollup),
-        country=args.country,
-        admin1_region=args.admin1_region,
-    )
+    options = RunMDSpeciesNetOptions()
+    args_to_object(args,options)
 
-    elapsed_time = time.time() - start_time
-    print(
-        'Processing complete in {}'.format(humanfriendly.format_timespan(elapsed_time)))
-    print('Results written to: {}'.format(args.output_file))
-
-    # Clean up intermediate files if requested
-    if (not args.keep_intermediate_files) and \
-       (not args.intermediate_file_folder) and \
-       (not args.detections_file):
-        try:
-            os.remove(detector_output_file)
-        except Exception as e:
-            print('Warning: error removing temporary output file {}: {}'.format(
-                detector_output_file, str(e)))
+    run_md_and_speciesnet(options)
 
 # ...def main(...)
 

megadetector/detection/run_tiled_inference.py

@@ -510,9 +510,9 @@ def run_tiled_inference(model_file,
                 try:
                     fn_relative = os.path.relpath(fn,image_folder)
                 except ValueError:
-                    'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
-                        fn,image_folder)
-                    raise
+                    raise ValueError(
+                        'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
+                        fn,image_folder))
                 assert not fn_relative.startswith('..'), \
                     'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
                         fn,image_folder)
@@ -619,12 +619,12 @@ def run_tiled_inference(model_file,
     else:
 
         patch_file_names = []
-        for im in all_image_patch_info:
+        for patch_info in all_image_patch_info:
             # If there was a patch generation error, don't run inference
             if patch_info['error'] is not None:
-                assert im['image_fn'] in images_with_patch_errors
+                assert patch_info['image_fn'] in images_with_patch_errors
                 continue
-            for patch in im['patches']:
+            for patch in patch_info['patches']:
                 patch_file_names.append(patch['patch_fn'])
 
         inference_results = load_and_run_detector_batch(model_file,
@@ -952,7 +952,7 @@ def main():
     parser.add_argument(
         '--tile_size_y',
         type=int,
-        default=default_tile_size[0],
+        default=default_tile_size[1],
         help=('Tile height (defaults to {})'.format(default_tile_size[1])))
     parser.add_argument(
         '--tile_overlap',

megadetector/detection/tf_detector.py

@@ -42,7 +42,7 @@ class TFDetector:
         input and output tensor handles.
 
         Args:
-            model_path (str): path to .pdb file
+            model_path (str): path to .pb file
             detector_options (dict, optional): key-value pairs that control detector
                 options; currently not used by TFDetector
         """

megadetector/detection/video_utils.py

@@ -221,11 +221,13 @@ def frames_to_video(images, fs, output_file_name, codec_spec=default_fourcc):
         print('Warning: no frames to render')
         return
 
-    os.makedirs(os.path.dirname(output_file_name),exist_ok=True)
+    output_dir = os.path.dirname(output_file_name)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir, exist_ok=True)
 
     # Determine the width and height from the first image
     frame = cv2.imread(images[0])
-    cv2.imshow('video',frame)
+    # cv2.imshow('video',frame)
     height, width, channels = frame.shape
 
     # Define the codec and create VideoWriter object
@@ -297,7 +299,7 @@ def _filename_to_frame_number(filename):
     try:
         frame_number = int(frame_number)
     except Exception:
-        raise ValueError('Filename {} does contain a valid frame number'.format(filename))
+        raise ValueError('Filename {} does not contain a valid frame number'.format(filename))
 
     return frame_number
 
@@ -1059,9 +1061,10 @@ def video_folder_to_frames(input_folder,
 
         finally:
 
-            pool.close()
-            pool.join()
-            print('Pool closed and joined for video processing')
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print('Pool closed and joined for video processing')
 
         # ...try/finally
 

megadetector/postprocessing/add_max_conf.py

@@ -18,7 +18,8 @@ import json
 import sys
 import argparse
 
-from megadetector.utils import ct_utils
+from megadetector.utils.ct_utils import get_max_conf
+from megadetector.utils.ct_utils import write_json
 
 
 #%% Main function
@@ -39,15 +40,14 @@ def add_max_conf(input_file,output_file):
 
     for im in d['images']:
 
-        max_conf = ct_utils.get_max_conf(im)
+        max_conf = get_max_conf(im)
 
         if 'max_detection_conf' in im:
             assert abs(max_conf - im['max_detection_conf']) < 0.00001
         else:
             im['max_detection_conf'] = max_conf
 
-    with open(output_file,'w') as f:
-        json.dump(d,f,indent=1)
+    write_json(output_file,d)
 
 
 #%% Driver

megadetector/postprocessing/categorize_detections_by_size.py

@@ -14,6 +14,8 @@ import json
 from collections import defaultdict
 from tqdm import tqdm
 
+from megadetector.utils.ct_utils import write_json
+
 
 #%% Support classes
 
@@ -157,8 +159,7 @@ def categorize_detections_by_size(input_file,output_file=None,options=None):
         print('Found {} detections in category {}'.format(category_count,category_name))
 
     if output_file is not None:
-        with open(output_file,'w') as f:
-            json.dump(data,f,indent=1)
+        write_json(output_file,data)
 
     return data