megadetector 5.0.12__py3-none-any.whl → 5.0.14__py3-none-any.whl

megadetector/detection/tf_detector.py

@@ -125,8 +125,13 @@ class TFDetector:
         return box_tensor_out, score_tensor_out, class_tensor_out
 
 
-    def generate_detections_one_image(self, image, image_id, detection_threshold, image_size=None,
-                                      skip_image_resizing=False):
+    def generate_detections_one_image(self, 
+                                      image, 
+                                      image_id, 
+                                      detection_threshold, 
+                                      image_size=None,
+                                      skip_image_resizing=False,
+                                      augment=False):
         """
         Runs the detector on an image.
 
@@ -139,7 +144,9 @@ class TFDetector:
                 if (a) you're using a model other than MegaDetector or (b) you know what you're
                 doing
             skip_image_resizing (bool, optional): whether to skip internal image resizing (and rely on external 
-                resizing)... not currently supported, but included here for compatibility with PTDetector.
+                resizing).  Not currently supported, but included here for compatibility with PTDetector.
+            augment (bool, optional): enable image augmentation.  Not currently  supported, but included 
+                here for compatibility with PTDetector.
 
         Returns:
             dict: a dictionary with the following fields:
@@ -151,7 +158,11 @@ class TFDetector:
         
         assert image_size is None, 'Image sizing not supported for TF detectors'
         assert not skip_image_resizing, 'Image sizing not supported for TF detectors'
+        assert not augment, 'Image augmentation is not supported for TF detectors'
         
+        if detection_threshold is None:
+            detection_threshold = 0
+            
         result = { 'file': image_id }
         
         try:

megadetector/detection/video_utils.py

@@ -9,6 +9,7 @@ Utilities for splitting, rendering, and assembling videos.
 #%% Constants, imports, environment
 
 import os
+import re
 import cv2
 import glob
 import json
@@ -18,6 +19,7 @@ from multiprocessing.pool import ThreadPool
 from multiprocessing.pool import Pool
 from tqdm import tqdm
 from functools import partial
+from inspect import signature
 
 from megadetector.utils import path_utils    
 from megadetector.visualization import visualization_utils as vis_utils
@@ -92,10 +94,12 @@ def find_videos(dirname,
     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)
 
 
-#%% Function for rendering frames to video and vice-versa
+#%% Functions for rendering frames to video and vice-versa
 
 # http://tsaith.github.io/combine-images-into-a-video-with-python-3-and-opencv-3.html
 
@@ -118,8 +122,11 @@ def frames_to_video(images, Fs, output_file_name, codec_spec=default_fourcc):
         codec_spec = 'h264'
         
     if len(images) == 0:
+        print('Warning: no frames to render')
         return
 
+    os.makedirs(os.path.dirname(output_file_name),exist_ok=True)
+    
     # Determine the width and height from the first image
     frame = cv2.imread(images[0])
     cv2.imshow('video',frame)
@@ -163,8 +170,55 @@ def _frame_number_to_filename(frame_number):
     return 'frame{:06d}.jpg'.format(frame_number)
 
 
-def video_to_frames(input_video_file, output_folder, overwrite=True, 
-                    every_n_frames=None, verbose=False):
+def _filename_to_frame_number(filename):
+    """
+    Extract the frame number from a filename that was created using 
+    _frame_number_to_filename.
+    
+    Args:
+        filename (str): a filename created with _frame_number_to_filename.
+    Returns:
+        int: the frame number extracted from [filename]
+    """
+    
+    filename = os.path.basename(filename)
+    match = re.search(r'frame(\d+)\.jpg', filename)
+    if match is None:
+        raise ValueError('{} does not appear to be a frame file'.format(filename))
+    frame_number = match.group(1)
+    try:
+        frame_number = int(frame_number)
+    except:
+        raise ValueError('Filename {} does contain a valid frame number'.format(filename))
+        
+    return frame_number
+
+
+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.
+    
+    Args:
+        results (list): list of image dicts        
+    """
+    
+    # Add video-specific fields to the results
+    for im in results:
+        fn = im['file']
+        frame_number = _filename_to_frame_number(fn)
+        im['frame_number'] = frame_number
+    
+
+def video_to_frames(input_video_file, 
+                    output_folder, 
+                    overwrite=True, 
+                    every_n_frames=None, 
+                    verbose=False, 
+                    quality=None,
+                    max_width=None, 
+                    frames_to_extract=None,
+                    allow_empty_videos=False):
     """
     Renders frames from [input_video_file] to a .jpg in [output_folder].
     
@@ -177,8 +231,18 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
         output_folder (str): folder to put frame images in
         overwrite (bool, optional): whether to overwrite existing frame images
         every_n_frames (int, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is extracted
+            if this is None or 1, every frame is extracted. Mutually exclusive with
+            frames_to_extract.
         verbose (bool, optional): enable additional debug console output
+        quality (int, optional): JPEG quality for frame output, from 0-100.  Defaults
+            to the opencv default (typically 95).
+        max_width (int, optional): resize frames to be no wider than [max_width]
+        frames_to_extract (list of int, optional): extract 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:
         tuple: length-2 tuple containing (list of frame filenames,frame rate)
@@ -186,6 +250,14 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
     
     assert os.path.isfile(input_video_file), 'File {} not found'.format(input_video_file)
     
+    if isinstance(frames_to_extract,int):
+        frames_to_extract = [frames_to_extract]
+        
+    if (frames_to_extract is not None) and (every_n_frames is not None):
+        raise ValueError('frames_to_extract and every_n_frames are mutually exclusive')
+    
+    os.makedirs(output_folder,exist_ok=True)
+    
     vidcap = cv2.VideoCapture(input_video_file)
     n_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
     Fs = vidcap.get(cv2.CAP_PROP_FPS)
@@ -194,36 +266,74 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
     if overwrite == False:
         
         missing_frame_number = None
+        missing_frame_filename = None
         frame_filenames = []
+        found_existing_frame = False
         
         for frame_number in range(0,n_frames):
             
             if every_n_frames is not None:
-                if frame_number % every_n_frames != 0:
+                assert frames_to_extract is None, \
+                    'Internal error: frames_to_extract and every_n_frames are exclusive'
+                if (frame_number % every_n_frames) != 0:
                     continue
             
+            if frames_to_extract is not None:
+                assert every_n_frames is None, \
+                    'Internal error: frames_to_extract and every_n_frames are exclusive'
+                if frame_number not in frames_to_extract:
+                    continue
+                
             frame_filename = _frame_number_to_filename(frame_number)
             frame_filename = os.path.join(output_folder,frame_filename)
             frame_filenames.append(frame_filename)
             if os.path.isfile(frame_filename):
+                found_existing_frame = True
                 continue
             else:
                 missing_frame_number = frame_number
+                missing_frame_filename = frame_filename
                 break
     
+        if verbose and missing_frame_number is not None:
+            print('Missing frame {} ({}) for video {}'.format(
+                missing_frame_number,
+                missing_frame_filename,
+                input_video_file))
+            
         # OpenCV seems to over-report the number of frames by 1 in some cases, or fails
         # to read the last frame; either way, I'm allowing one missing frame.
         allow_last_frame_missing = True
         
-        if missing_frame_number is None or \
-            (allow_last_frame_missing and (missing_frame_number == n_frames-1)):
+        # This doesn't have to mean literally the last frame number, it just means that if
+        # we find this frame or later, we consider the video done
+        last_expected_frame_number = n_frames-1
+        if every_n_frames is not None:
+            last_expected_frame_number -= (every_n_frames*2)
+          
+        # When specific frames are requested, if anything is missing, reprocess the video
+        if (frames_to_extract is not None) and (missing_frame_number is not None):
+            
+            pass
+        
+        # If no frames are missing, or only frames very close to the end of the video are "missing",
+        # skip this video
+        elif (missing_frame_number is None) or \
+            (allow_last_frame_missing and (missing_frame_number >= last_expected_frame_number)):
+                
             if verbose:
                 print('Skipping video {}, all output frames exist'.format(input_video_file))
             return frame_filenames,Fs
+        
         else:
-            pass
-            # print("Rendering video {}, couldn't find frame {}".format(
-            #    input_video_file,missing_frame_number))
+            
+            # If we found some frames, but not all, print a message
+            if verbose and found_existing_frame:
+                print("Rendering video {}, couldn't find frame {} ({}) of {}".format(
+                    input_video_file,
+                    missing_frame_number,
+                    missing_frame_filename,
+                    last_expected_frame_number))
     
     # ...if we need to check whether to skip this video entirely
         
@@ -232,6 +342,32 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
 
     frame_filenames = []
 
+    # YOLOv5 does some totally bananas monkey-patching of opencv, which causes 
+    # problems  if we try to supply a third parameter to imwrite (to specify JPEG 
+    # quality).  Detect  this case, and ignore the quality  parameter if it looks 
+    # like imwrite has been messed with.
+    #
+    # See:
+    #
+    # https://github.com/ultralytics/yolov5/issues/7285
+    imwrite_patched = False
+    n_imwrite_parameters = None
+    
+    try:
+        # calling signature() on the native cv2.imwrite function will
+        # fail, so an exception here is a good thing.  In fact I don't think
+        # there's a case where this *succeeds* and the number of parameters
+        # is wrong.
+        sig = signature(cv2.imwrite)
+        n_imwrite_parameters = len(sig.parameters)
+    except Exception:
+        pass
+    
+    if (n_imwrite_parameters is not None) and (n_imwrite_parameters < 3):
+        imwrite_patched = True
+        if verbose and (quality is not None):
+            print('Warning: quality value supplied, but YOLOv5 has mucked with cv2.imwrite, ignoring quality')
+            
     # for frame_number in tqdm(range(0,n_frames)):
     for frame_number in range(0,n_frames):
 
@@ -245,7 +381,32 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
         if every_n_frames is not None:
             if frame_number % every_n_frames != 0:
                 continue
+
+        if frames_to_extract is not None:
+            if frame_number > max(frames_to_extract):
+                break
+            if frame_number not in frames_to_extract:
+                continue
             
+        # Has resizing been requested?
+        if max_width is not None:
+        
+            # image.shape is h/w/dims            
+            input_shape = image.shape
+            assert input_shape[2] == 3
+            input_width = input_shape[1]
+            
+            # Is resizing necessary?
+            if input_width > max_width:
+                
+                scale = max_width / input_width
+                assert scale <= 1.0
+                
+                # INTER_AREA is recommended for size reduction
+                image = cv2.resize(image, (0,0), fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
+        
+        # ...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_filenames.append(frame_filename)
@@ -256,9 +417,18 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
         else:
             try:
                 if frame_filename.isascii():
-                    cv2.imwrite(os.path.normpath(frame_filename),image)
+                    
+                    if quality is None or imwrite_patched:
+                        cv2.imwrite(os.path.normpath(frame_filename),image)
+                    else:                        
+                        cv2.imwrite(os.path.normpath(frame_filename),image,
+                                    [int(cv2.IMWRITE_JPEG_QUALITY), quality])
                 else:
-                    is_success, im_buf_arr = cv2.imencode('.jpg', image)
+                    if quality is None:
+                        is_success, im_buf_arr = cv2.imencode('.jpg', image)
+                    else:
+                        encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]
+                        is_success, im_buf_arr = cv2.imencode('.jpg', image, encode_param)
                     im_buf_arr.tofile(frame_filename)
                 assert os.path.isfile(frame_filename), \
                     'Output frame {} unavailable'.format(frame_filename)
@@ -268,8 +438,13 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
             except Exception as e:
                 print('Error on frame {} of {}: {}'.format(frame_number,n_frames,str(e)))
 
+    if len(frame_filenames) == 0:
+        raise Exception('Error: found no frames in file {}'.format(
+            input_video_file))
+        
     if verbose:
-        print('\nExtracted {} of {} frames'.format(len(frame_filenames),n_frames))
+        print('\nExtracted {} of {} frames for {}'.format(
+            len(frame_filenames),n_frames,input_video_file))
 
     vidcap.release()    
     return frame_filenames,Fs
@@ -277,10 +452,13 @@ def video_to_frames(input_video_file, output_folder, overwrite=True,
 # ...def video_to_frames(...)
 
 
-def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,every_n_frames,overwrite,verbose):
+def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,
+                                every_n_frames,overwrite,verbose,quality,max_width,
+                                frames_to_extract):
     """
-    Internal function to call video_to_frames in the context of video_folder_to_frames; 
-    makes sure the right output folder exists, then calls video_to_frames.
+    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 
+    video_to_frames.
     """    
     
     input_fn_absolute = os.path.join(input_folder,relative_fn)
@@ -295,7 +473,8 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,ever
     # 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)
+                                         verbose=verbose,quality=quality,max_width=max_width,
+                                         frames_to_extract=frames_to_extract)
     
     return frame_filenames,fs
 
@@ -303,7 +482,9 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,ever
 def video_folder_to_frames(input_folder, output_folder_base, 
                            recursive=True, overwrite=True,
                            n_threads=1, every_n_frames=None,
-                           verbose=False, parallelization_uses_threads=True):
+                           verbose=False, parallelization_uses_threads=True,
+                           quality=None, max_width=None, 
+                           frames_to_extract=None):
     """
     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.
@@ -317,11 +498,19 @@ def video_folder_to_frames(input_folder, output_folder_base,
         n_threads (int, optional): number of concurrent workers to use; set to <= 1 to disable
             parallelism
         every_n_frames (int, optional): sample every Nth frame starting from the first frame;
-            if this is None or 1, every frame is extracted
+            if this is None or 1, every frame is extracted. Mutually exclusive with 
+            frames_to_extract.
         verbose (bool, optional): enable additional debug console output
         parallelization_uses_threads (bool, optional): whether to use threads (True) or
             processes (False) for parallelization; ignored if n_threads <= 1
-            
+        quality (int, optional): JPEG quality for frame output, from 0-100.  Defaults
+            to the opencv default (typically 95).
+        max_width (int, optional): resize frames to be no wider than [max_width]
+        frames_to_extract (list of int, optional): extract this specific set of frames from
+            each video; mutually exclusive with every_n_frames.  If all values are beyond 
+            the length of a video, no frames are extracted. Can also be a single int, 
+            specifying a single frame number.
+        
     Returns:
         tuple: a length-3 tuple containing:
             - list of lists of frame filenames; the Nth list of frame filenames corresponds to 
@@ -352,7 +541,8 @@ 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)
+                                            every_n_frames,overwrite,verbose,quality,max_width,
+                                            frames_to_extract)
             frame_filenames_by_video.append(frame_filenames)
             fs_by_video.append(fs)
     else:
@@ -367,7 +557,10 @@ def video_folder_to_frames(input_folder, output_folder_base,
                                              output_folder_base=output_folder_base,
                                              every_n_frames=every_n_frames,
                                              overwrite=overwrite,
-                                             verbose=verbose)
+                                             verbose=verbose,
+                                             quality=quality,
+                                             max_width=max_width,
+                                             frames_to_extract=frames_to_extract)
         results = list(tqdm(pool.imap(
             partial(process_video_with_options),input_files_relative_paths), 
                             total=len(input_files_relative_paths)))
@@ -385,15 +578,17 @@ class FrameToVideoOptions:
     frame_results_to_video_results()    
     """
     
-    #: One-indexed indicator of which frame-level confidence value to use to determine detection confidence
-    #: for the whole video, i.e. "1" means "use the confidence value from the highest-confidence frame"
-    nth_highest_confidence = 1
-    
-    #: What to do if a file referred to in a .json results file appears not to be a 
-    #: video; can be 'error' or 'skip_with_warning'
-    non_video_behavior = 'error'
-    
+    def __init__(self):
+            
+        #: One-indexed indicator of which frame-level confidence value to use to determine detection confidence
+        #: for the whole video, i.e. "1" means "use the confidence value from the highest-confidence frame"
+        self.nth_highest_confidence = 1
+        
+        #: What to do if a file referred to in a .json results file appears not to be a 
+        #: video; can be 'error' or 'skip_with_warning'
+        self.non_video_behavior = 'error'
     
+
 def frame_results_to_video_results(input_file,output_file,options=None):
     """
     Given an MD results file produced at the *frame* level, corresponding to a directory 
@@ -419,16 +614,19 @@ def frame_results_to_video_results(input_file,output_file,options=None):
     images = input_data['images']
     detection_categories = input_data['detection_categories']
     
+    
     ## Break into videos
     
-    video_to_frames = defaultdict(list) 
+    video_to_frame_info = defaultdict(list) 
     
     # im = images[0]
     for im in tqdm(images):
         
         fn = im['file']
         video_name = os.path.dirname(fn)
+        
         if not is_video_file(video_name):
+            
             if options.non_video_behavior == 'error':
                 raise ValueError('{} is not a video file'.format(video_name))
             elif options.non_video_behavior == 'skip_with_warning':
@@ -437,25 +635,37 @@ def frame_results_to_video_results(input_file,output_file,options=None):
             else:
                 raise ValueError('Unrecognized non-video handling behavior: {}'.format(
                     options.non_video_behavior))
-        video_to_frames[video_name].append(im)
+        
+        # Attach video-specific fields to the output, specifically attach the frame
+        # number to both the video and each detection.  Only the frame number for the 
+        # canonical detection will end up in the video-level output file.
+        frame_number = _filename_to_frame_number(fn)
+        im['frame_number'] = frame_number
+        for detection in im['detections']: 
+            detection['frame_number'] = frame_number
+        
+        video_to_frame_info[video_name].append(im)
+    
+    # ...for each frame referred to in the results file
     
     print('Found {} unique videos in {} frame-level results'.format(
-        len(video_to_frames),len(images)))
+        len(video_to_frame_info),len(images)))
     
     output_images = []
     
+    
     ## For each video...
     
-    # video_name = list(video_to_frames.keys())[0]
-    for video_name in tqdm(video_to_frames):
+    # video_name = list(video_to_frame_info.keys())[0]
+    for video_name in tqdm(video_to_frame_info):
         
-        frames = video_to_frames[video_name]
+        frames = video_to_frame_info[video_name]
         
         all_detections_this_video = []
         
         # frame = frames[0]
         for frame in frames:
-            if frame['detections'] is not None:
+            if ('detections' in frame) and (frame['detections'] is not None):
                 all_detections_this_video.extend(frame['detections'])
             
         # At most one detection for each category for the whole video
@@ -502,37 +712,60 @@ def frame_results_to_video_results(input_file,output_file,options=None):
 # ...def frame_results_to_video_results(...)
 
 
-#%% Test driver
+#%% Test drivers
 
 if False:
 
+    pass
+
     #%% Constants
     
-    Fs = 30.01
-    confidence_threshold = 0.75
-    input_folder = 'z:\\'
-    frame_folder_base = r'e:\video_test\frames'
-    detected_frame_folder_base = r'e:\video_test\detected_frames'
-    rendered_videos_folder_base = r'e:\video_test\rendered_videos'
-    
-    results_file = r'results.json'
-    os.makedirs(detected_frame_folder_base,exist_ok=True)
-    os.makedirs(rendered_videos_folder_base,exist_ok=True)
-    
+    input_folder = r'G:\temp\usu-long\data'
+    frame_folder_base = r'g:\temp\usu-long-single-frames'
+    assert os.path.isdir(input_folder)
+        
     
     #%% Split videos into frames
         
     frame_filenames_by_video,fs_by_video,video_filenames = \
-        video_folder_to_frames(input_folder,frame_folder_base,recursive=True)
+        video_folder_to_frames(input_folder,
+                               frame_folder_base,
+                               recursive=True,
+                               overwrite=True,
+                               n_threads=10, 
+                               every_n_frames=None,
+                               verbose=True, 
+                               parallelization_uses_threads=True,
+                               quality=None, 
+                               max_width=None, 
+                               frames_to_extract=150)
+    
     
+    #%% Constants for detection tests
+    
+    detected_frame_folder_base = r'e:\video_test\detected_frames'
+    rendered_videos_folder_base = r'e:\video_test\rendered_videos'
+    os.makedirs(detected_frame_folder_base,exist_ok=True)
+    os.makedirs(rendered_videos_folder_base,exist_ok=True)
+    results_file = r'results.json'
+    confidence_threshold = 0.75
+        
+    #%% Load detector output    
     
+    with open(results_file,'r') as f:
+        detection_results = json.load(f)
+    detections = detection_results['images']
+    detector_label_map = detection_results['detection_categories']
+    for d in detections:
+        d['file'] = d['file'].replace('\\','/').replace('video_frames/','')
+
+
     #%% List image files, break into folders
     
     frame_files = path_utils.find_images(frame_folder_base,True)
     frame_files = [s.replace('\\','/') for s in frame_files]
     print('Enumerated {} total frames'.format(len(frame_files)))
     
-    Fs = 30.01
     # Find unique folders
     folders = set()
     # fn = frame_files[0]
@@ -542,16 +775,6 @@ if False:
     print('Found {} folders for {} files'.format(len(folders),len(frame_files)))
     
         
-    #%% Load detector output
-    
-    with open(results_file,'r') as f:
-        detection_results = json.load(f)
-    detections = detection_results['images']
-    detector_label_map = detection_results['detection_categories']
-    for d in detections:
-        d['file'] = d['file'].replace('\\','/').replace('video_frames/','')
-
-
     #%% Render detector frames
     
     # folder = list(folders)[0]

megadetector/postprocessing/categorize_detections_by_size.py

@@ -22,20 +22,22 @@ class SizeCategorizationOptions:
     Options used to parameterize categorize_detections_by_size().
     """
     
-    #: Thresholds to use for separation, as a fraction of the image size.
-    #:
-    #: Should be sorted from smallest to largest.
-    size_thresholds = [0.95]
-    
-    #: List of category numbers to use in separation; uses all categories if None
-    categories_to_separate = None
-    
-    #: Dimension to use for thresholding; can be "size", "width", or "height"
-    measurement = 'size'
-    
-    #: Categories to assign to thresholded ranges; should have the same length as
-    #: "size_thresholds".
-    size_category_names = ['large_detection']
+    def __init__(self):
+        
+        #: Thresholds to use for separation, as a fraction of the image size.
+        #:
+        #: Should be sorted from smallest to largest.
+        self.size_thresholds = [0.95]
+        
+        #: List of category numbers to use in separation; uses all categories if None
+        self.categories_to_separate = None
+        
+        #: Dimension to use for thresholding; can be "size", "width", or "height"
+        self.measurement = 'size'
+        
+        #: Categories to assign to thresholded ranges; should have the same length as
+        #: "size_thresholds".
+        self.size_category_names = ['large_detection']
     
                                                  
 #%% Main functions