megadetector 5.0.6__py3-none-any.whl → 5.0.8__py3-none-any.whl

detection/run_tiled_inference.py

@@ -29,6 +29,7 @@ from tqdm import tqdm
 
 from detection.run_inference_with_yolov5_val import YoloInferenceOptions,run_inference_with_yolo_val
 from detection.run_detector_batch import load_and_run_detector_batch,write_results_to_file
+from detection.run_detector import try_download_known_detector
 
 import torch
 from torchvision import ops
@@ -234,7 +235,7 @@ def in_place_nms(md_results, iou_thres=0.45, verbose=True):
     # i_image = 18; im = md_results['images'][i_image]
     for i_image,im in tqdm(enumerate(md_results['images']),total=len(md_results['images'])):
         
-        if len(im['detections']) == 0:
+        if (im['detections'] is None) or (len(im['detections']) == 0):
             continue
     
         boxes = []
@@ -282,40 +283,52 @@ def in_place_nms(md_results, iou_thres=0.45, verbose=True):
 
 def _extract_tiles_for_image(fn_relative,image_folder,tiling_folder,patch_size,patch_stride,overwrite):
     """
-    Extract tiles for a single image
+    Private function to extract tiles for a single image.
     
-    Not really a standalone function; isolated from the main function to simplify
-    multiprocessing.
+    Returns a dict with fields 'patches' (see extract_patch_from_image) and 'image_fn'.
+    
+    If there is an error, 'patches' will be None and the 'error' field will contain
+    failure details.  In that case, some tiles may still be generated.
     """
     
     fn_abs = os.path.join(image_folder,fn_relative)
+    error = None
+    patches = []        
     
     image_name = path_utils.clean_filename(fn_relative,char_limit=None,force_lower=True)
     
-    # Open the image
-    im = vis_utils.open_image(fn_abs)
-    image_size = [im.width,im.height]
+    try:
+        
+        # Open the image
+        im = vis_utils.open_image(fn_abs)
+        image_size = [im.width,im.height]
+                
+        # Generate patch boundaries (a list of [x,y] starting points)
+        patch_boundaries = get_patch_boundaries(image_size,patch_size,patch_stride)        
+        
+        # Extract patches
+        #
+        # patch_xy = patch_boundaries[0]        
+        for patch_xy in patch_boundaries:
             
-    # Generate patch boundaries (a list of [x,y] starting points)
-    patch_boundaries = get_patch_boundaries(image_size,patch_size,patch_stride)        
-    
-    # Extract patches
-    #
-    # patch_xy = patch_boundaries[0]
-    patches = []
-    
-    for patch_xy in patch_boundaries:
+            patch_info = extract_patch_from_image(im,patch_xy,patch_size,
+                                     patch_folder=tiling_folder,
+                                     image_name=image_name,
+                                     overwrite=overwrite)
+            patch_info['source_fn'] = fn_relative
+            patches.append(patch_info)
         
-        patch_info = extract_patch_from_image(im,patch_xy,patch_size,
-                                 patch_folder=tiling_folder,
-                                 image_name=image_name,
-                                 overwrite=overwrite)
-        patch_info['source_fn'] = fn_relative
-        patches.append(patch_info)
+    except Exception as e:
+        
+        s = 'Patch generation error for {}: \n{}'.format(fn_relative,str(e))
+        print(s)
+        # patches = None
+        error = s
         
     image_patch_info = {}
     image_patch_info['patches'] = patches
     image_patch_info['image_fn'] = fn_relative
+    image_patch_info['error'] = error
     
     return image_patch_info
     
@@ -327,7 +340,8 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
                         checkpoint_path=None, checkpoint_frequency=-1, remove_tiles=False, 
                         yolo_inference_options=None,
                         n_patch_extraction_workers=default_n_patch_extraction_workers,
-                        overwrite_tiles=True):
+                        overwrite_tiles=True,
+                        image_list=None):
     """
     Run inference using [model_file] on the images in [image_folder], fist splitting each image up 
     into tiles of size [tile_size_x] x [tile_size_y], writing those tiles to [tiling_folder],
@@ -337,7 +351,8 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     [tiling_folder] can be any folder, but this function reserves the right to do whatever it wants
     within that folder, including deleting everything, so it's best if it's a new folder.  
     Conceptually this folder is temporary, it's just helpful in this case to not actually
-    use the system temp folder, because the tile cache may be very large, 
+    use the system temp folder, because the tile cache may be very large, so the caller may 
+    want it to be on a specific drive.
     
     tile_overlap is the fraction of overlap between tiles.
     
@@ -346,25 +361,54 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     if yolo_inference_options is supplied, it should be an instance of YoloInferenceOptions; in 
     this case the model will be run with run_inference_with_yolov5_val.  This is typically used to 
     run the model with test-time augmentation.          
-    """    
+    """
 
     ##%% Validate arguments
     
     assert tile_overlap < 1 and tile_overlap >= 0, \
         'Illegal tile overlap value {}'.format(tile_overlap)
     
+    if tile_size_x == -1:
+        tile_size_x = default_tile_size[0]
+    if tile_size_y == -1:
+        tile_size_y = default_tile_size[1]
+        
     patch_size = [tile_size_x,tile_size_y]
     patch_stride = (round(patch_size[0]*(1.0-tile_overlap)),
                     round(patch_size[1]*(1.0-tile_overlap)))
     
     os.makedirs(tiling_folder,exist_ok=True)
     
-    
     ##%% List files
     
-    image_files_relative = path_utils.find_images(image_folder, recursive=True, return_relative_paths=True)    
-    assert len(image_files_relative) > 0, 'No images found in folder {}'.format(image_folder)
-    
+    if image_list is None:
+        
+        print('Enumerating images in {}'.format(image_folder))
+        image_files_relative = path_utils.find_images(image_folder, recursive=True, return_relative_paths=True)    
+        assert len(image_files_relative) > 0, 'No images found in folder {}'.format(image_folder)
+        
+    else:
+        
+        print('Loading image list from {}'.format(image_list))
+        with open(image_list,'r') as f:
+            image_files_relative = json.load(f)
+        n_absolute_paths = 0
+        for i_fn,fn in enumerate(image_files_relative):
+            if os.path.isabs(fn):
+                n_absolute_paths += 1
+                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
+                assert not fn_relative.startswith('..'), \
+                    'Illegal absolute path supplied to run_tiled_inference, {} is outside of {}'.format(
+                        fn,image_folder)
+                image_files_relative[i_fn] = fn_relative
+        if (n_absolute_paths != 0) and (n_absolute_paths != len(image_files_relative)):
+            raise ValueError('Illegal file list: converted {} of {} paths to relative'.format(
+            n_absolute_paths,len(image_files_relative)))
     
     ##%% Generate tiles
     
@@ -414,7 +458,7 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
                 image_files_relative),total=len(image_files_relative)))
         
     # ...for each image
-        
+    
     # Write tile information to file; this is just a debugging convenience
     folder_name = path_utils.clean_filename(image_folder,force_lower=True)
     if folder_name.startswith('_'):
@@ -424,9 +468,16 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     with open(tile_cache_file,'w') as f:
         json.dump(all_image_patch_info,f,indent=1)
     
+    # Keep track of patches that failed
+    images_with_patch_errors = {}
+    for patch_info in all_image_patch_info:
+        if patch_info['error'] is not None:
+            images_with_patch_errors[patch_info['image_fn']] = patch_info
+    
     
     ##%% Run inference on tiles
     
+    # When running with run_inference_with_yolov5_val, we'll pass the folder
     if yolo_inference_options is not None:
         
         patch_level_output_file = os.path.join(tiling_folder,folder_name + '_patch_level_results.json')
@@ -444,11 +495,16 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
         run_inference_with_yolo_val(yolo_inference_options)
         with open(patch_level_output_file,'r') as f:
             patch_level_results = json.load(f)
-                    
+    
+    # For standard inference, we'll pass a list of files
     else:
         
         patch_file_names = []
         for im 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
+                continue
             for patch in im['patches']:
                 patch_file_names.append(patch['patch_fn'])
                 
@@ -481,18 +537,44 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
     image_fn_relative_to_patch_info = { x['image_fn']:x for x in all_image_patch_info }
     
     # i_image = 0; image_fn_relative = image_files_relative[i_image]
-    for i_image,image_fn_relative in tqdm(enumerate(image_files_relative),total=len(image_files_relative)):
+    for i_image,image_fn_relative in tqdm(enumerate(image_files_relative),
+                                          total=len(image_files_relative)):
         
         image_fn_abs = os.path.join(image_folder,image_fn_relative)
         assert os.path.isfile(image_fn_abs)
                 
         output_im = {}
         output_im['file'] = image_fn_relative
-        output_im['detections'] = []
+        
+        # If we had a patch generation error
+        if image_fn_relative in images_with_patch_errors:
             
-        pil_im = vis_utils.open_image(image_fn_abs)        
-        image_w = pil_im.size[0]
-        image_h = pil_im.size[1]
+            patch_info = image_fn_relative_to_patch_info[image_fn_relative]
+            assert patch_info['error'] is not None
+            
+            output_im['detections'] = None
+            output_im['failure'] = 'Patch generation error'
+            output_im['failure_details'] = patch_info['error']
+            image_level_results['images'].append(output_im)
+            continue
+                    
+        try:
+            pil_im = vis_utils.open_image(image_fn_abs)        
+            image_w = pil_im.size[0]
+            image_h = pil_im.size[1]
+        
+        # This would be a very unusual situation; we're reading back an image here that we already
+        # (successfully) read once during patch generation.
+        except Exception as e:
+            print('Warning: image read error after successful patch generation for {}:\n{}'.format(
+                image_fn_relative,str(e)))
+            output_im['detections'] = None
+            output_im['failure'] = 'Patch processing error'
+            output_im['failure_details'] = str(e)
+            image_level_results['images'].append(output_im)
+            continue            
+        
+        output_im['detections'] = []
         
         image_patch_info = image_fn_relative_to_patch_info[image_fn_relative]
         assert image_patch_info['patches'][0]['source_fn'] == image_fn_relative
@@ -520,6 +602,14 @@ def run_tiled_inference(model_file, image_folder, tiling_folder, output_file,
             assert patch_w == patch_size[0]
             assert patch_h == patch_size[1]
             
+            # If there was an inference failure on one patch, report the image
+            # as an inference failure
+            if 'detections' not in patch_results:
+                assert 'failure' in patch_results
+                output_im['detections'] = None
+                output_im['failure'] = patch_results['failure']
+                break
+            
             # det = patch_results['detections'][0]
             for det in patch_results['detections']:
             
@@ -703,7 +793,7 @@ def main():
         help='Path to detector model file (.pb or .pt)')
     parser.add_argument(
         'image_folder',
-        help='Folder containing images for inference (always recursive)')
+        help='Folder containing images for inference (always recursive, unless image_list is supplied)')
     parser.add_argument(
         'tiling_folder',
         help='Temporary folder where tiles and intermediate results will be stored')
@@ -729,6 +819,16 @@ def main():
         type=float,
         default=default_patch_overlap,
         help=('Overlap between tiles [0,1] (defaults to {})'.format(default_patch_overlap)))
+    parser.add_argument(
+        '--overwrite_handling',
+        type=str,
+        default='skip',
+        help=('Behavior when the target file exists (skip/overwrite/error) (default skip)'))
+    parser.add_argument(
+        '--image_list',
+        type=str,
+        default=None,
+        help=('A .json list of relative filenames (or absolute paths contained within image_folder) to include'))
         
     if len(sys.argv[1:]) == 0:
         parser.print_help()
@@ -736,19 +836,29 @@ def main():
 
     args = parser.parse_args()
 
-    assert os.path.exists(args.model_file), \
+    model_file = try_download_known_detector(args.model_file)
+    assert os.path.exists(model_file), \
         'detector file {} does not exist'.format(args.model_file)
-    
+        
     if os.path.exists(args.output_file):
-        print('Warning: output_file {} already exists and will be overwritten'.format(
-            args.output_file))
+        if args.overwrite_handling == 'skip':
+            print('Warning: output file {} exists, skipping'.format(args.output_file))
+            return
+        elif args.overwrite_handling == 'overwrite':
+            print('Warning: output file {} exists, overwriting'.format(args.output_file))
+        elif args.overwrite_handling == 'error':
+            raise ValueError('Output file {} exists'.format(args.output_file))
+        else:
+            raise ValueError('Unknown output handling method {}'.format(args.overwrite_handling))
+        
 
     remove_tiles = (not args.no_remove_tiles)
 
-    run_tiled_inference(args.model_file, args.image_folder, args.tiling_folder, args.output_file,
+    run_tiled_inference(model_file, args.image_folder, args.tiling_folder, args.output_file,
                         tile_size_x=args.tile_size_x, tile_size_y=args.tile_size_y, 
                         tile_overlap=args.tile_overlap,
-                        remove_tiles=remove_tiles)
+                        remove_tiles=remove_tiles,
+                        image_list=args.image_list)
         
 if __name__ == '__main__':
     main()

detection/tf_detector.py

@@ -122,7 +122,8 @@ class TFDetector:
             detection_threshold: confidence above which to include the detection proposal
 
         Returns:
-        A dict with the following fields, see the 'images' key in https://github.com/agentmorris/MegaDetector/tree/master/api/batch_processing#batch-processing-api-output-format
+        A dict with the following fields, see the 'images' key in:
+        https://github.com/agentmorris/MegaDetector/tree/master/api/batch_processing#batch-processing-api-output-format
             - 'file' (always present)
             - 'max_detection_conf'
             - 'detections', which is a list of detection objects containing keys 'category', 'conf' and 'bbox'

detection/video_utils.py

@@ -24,6 +24,8 @@ from md_utils import path_utils
     
 from md_visualization import visualization_utils as vis_utils
 
+default_fourcc = 'h264'
+
 
 #%% Path utilities
 
@@ -76,7 +78,7 @@ def find_videos(dirname: str, recursive: bool = False,
 
 # http://tsaith.github.io/combine-images-into-a-video-with-python-3-and-opencv-3.html
 
-def frames_to_video(images, Fs, output_file_name, codec_spec='h264'):
+def frames_to_video(images, Fs, output_file_name, codec_spec=default_fourcc):
     """
     Given a list of image files and a sample rate, concatenate those images into
     a video and write to [output_file_name].
@@ -308,7 +310,7 @@ def video_folder_to_frames(input_folder:str, output_folder_base:str,
 
 class FrameToVideoOptions:
     
-    # zero-indexed
+    # One-indexed, i.e. "1" means "use the confidence value from the highest-confidence frame"
     nth_highest_confidence = 1
     
     # 'error' or 'skip_with_warning'

md_utils/ct_utils.py

@@ -39,9 +39,13 @@ def truncate_float_array(xs, precision=3):
 
 def truncate_float(x, precision=3):
     """
-    Truncates a floating-point value to a specific number of significant digits.
+    Truncates the fractional portion of a floating-point value to a specific number of 
+    floating-point digits.
     
-    For example: truncate_float(0.0003214884) --> 0.000321
+    For example: 
+        
+        truncate_float(0.0003214884) --> 0.000321
+        truncate_float(1.0003214884) --> 1.000321
     
     This function is primarily used to achieve a certain float representation
     before exporting to JSON.
@@ -58,13 +62,18 @@ def truncate_float(x, precision=3):
         
         return 0
     
+    elif (x > 1):
+        
+        fractional_component = x - 1.0
+        return 1 + truncate_float(fractional_component)
+    
     else:
         
         # Determine the factor, which shifts the decimal point of x
         # just behind the last significant digit.
         factor = math.pow(10, precision - 1 - math.floor(math.log10(abs(x))))
         
-        # Shift decimal point by multiplicatipon with factor, flooring, and
+        # Shift decimal point by multiplication with factor, flooring, and
         # division by factor.
         return math.floor(x * factor)/factor
 
@@ -174,6 +183,7 @@ def convert_xywh_to_xyxy(api_bbox):
     Converts an xywh bounding box to an xyxy bounding box.
 
     Note that this is also different from the TensorFlow Object Detection API coords format.
+    
     Args:
         api_bbox: bbox output by the batch processing API [x_min, y_min, width_of_box, height_of_box]
 
@@ -266,6 +276,7 @@ def point_dist(p1,p2):
     """
     Distance between two points, represented as length-two tuples.
     """
+    
     return math.sqrt( ((p1[0]-p2[0])**2) + ((p1[1]-p2[1])**2) )
 
 
@@ -328,23 +339,107 @@ def split_list_into_fixed_size_chunks(L,n):
     return [L[i * n:(i + 1) * n] for i in range((len(L) + n - 1) // n )]
 
 
-def split_list_into_n_chunks(L, n):
+def split_list_into_n_chunks(L, n, chunk_strategy='greedy'):
     """
     Splits the list or tuple L into n equally-sized chunks (some chunks may be one 
     element smaller than others, i.e. len(L) does not have to be a multiple of n.
+    
+    chunk_strategy can be "greedy" (default, if there are k samples per chunk, the first
+    k go into the first chunk) or "balanced" (alternate between chunks when pulling
+    items from the list).
+    """
+    
+    if chunk_strategy == 'greedy':
+        k, m = divmod(len(L), n)
+        return list(L[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n))
+    elif chunk_strategy == 'balanced':
+        chunks = [ [] for _ in range(n) ]
+        for i_item,item in enumerate(L):
+            i_chunk = i_item % n
+            chunks[i_chunk].append(item)
+        return chunks
+    else:
+        raise ValueError('Invalid chunk strategy: {}'.format(chunk_strategy))
+
+
+def sort_dictionary_by_key(d,reverse=False):
+    """
+    Sorts the dictionary [d] by key.
     """
     
-    k, m = divmod(len(L), n)
-    return list(L[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n))
+    d = dict(sorted(d.items(),reverse=reverse))
+    return d
+    
 
+def sort_dictionary_by_value(d,sort_values=None,reverse=False):
+    """
+    Sorts the dictionary [d] by value.  If sort_values is None, uses d.values(),
+    otherwise uses the dictionary sort_values as the sorting criterion.
+    """
+    
+    if sort_values is None:
+        d = {k: v for k, v in sorted(d.items(), key=lambda item: item[1], reverse=reverse)}
+    else:
+        d = {k: v for k, v in sorted(d.items(), key=lambda item: sort_values[item[0]], reverse=reverse)}
+    return d
 
 
+def invert_dictionary(d):
+    """
+    Create a new dictionary that maps d.values() to d.keys().  Does not check
+    uniqueness.    
+    """
+    
+    return {v: k for k, v in d.items()}
+
+
+def image_file_to_camera_folder(image_fn):
+    """
+    Remove common overflow folders (e.g. RECNX101, RECNX102) from paths, i.e. turn:
+        
+    a\b\c\RECNX101\image001.jpg
+    
+    ...into:
+        
+    a\b\c
+
+    Returns the same thing as os.dirname() (i.e., just the folder name) if no overflow folders are 
+    present.
+
+    Always converts backslashes to slashes.
+    """
+    
+    import re
+    
+    # 100RECNX is the overflow folder style for Reconyx cameras
+    # 100EK113 is (for some reason) the overflow folder style for Bushnell cameras
+    # 100_BTCF is the overflow folder style for Browning cameras
+    # 100MEDIA is the overflow folder style used on a number of consumer-grade cameras
+    patterns = ['\/\d+RECNX\/','\/\d+EK\d+\/','\/\d+_BTCF\/','\/\d+MEDIA\/']
+    
+    image_fn = image_fn.replace('\\','/')    
+    for pat in patterns:
+        image_fn = re.sub(pat,'/',image_fn)
+    camera_folder = os.path.dirname(image_fn)
+    
+    return camera_folder
+    
+
 #%% Test drivers
 
 if False:
     
     pass
     
+    #%% Test image_file_to_camera_folder()
+    
+    relative_path = 'a/b/c/d/100EK113/blah.jpg'
+    print(image_file_to_camera_folder(relative_path))
+    
+    relative_path = 'a/b/c/d/100RECNX/blah.jpg'
+    print(image_file_to_camera_folder(relative_path))
+    
+    
     #%% Test a few rectangle distances
     
     r1 = [0,0,1,1]; r2 = [0,0,1,1]; assert rect_distance(r1,r2)==0