megadetector 5.0.5__py3-none-any.whl → 5.0.7__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 targt 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/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
 
@@ -49,24 +51,34 @@ def find_video_strings(strings: Iterable[str]) -> List[str]:
     return [s for s in strings if is_video_file(s.lower())]
 
 
-def find_videos(dirname: str, recursive: bool = False) -> List[str]:
+def find_videos(dirname: str, recursive: bool = False,
+                convert_slashes: bool=False,
+                return_relative_paths: bool=False) -> List[str]:
     """
     Finds all files in a directory that look like video file names. Returns
-    absolute paths.
+    absolute paths unless return_relative_paths is set.  Uses the native
+    path separator unless convert_slashes is set.
     """
     
     if recursive:
-        strings = glob.glob(os.path.join(dirname, '**', '*.*'), recursive=True)
+        files = glob.glob(os.path.join(dirname, '**', '*.*'), recursive=True)
     else:
-        strings = glob.glob(os.path.join(dirname, '*.*'))
-    return find_video_strings(strings)
+        files = glob.glob(os.path.join(dirname, '*.*'))
+        
+    if return_relative_paths:
+        files = [os.path.relpath(fn,dirname) for fn in files]
+
+    if convert_slashes:
+        files = [fn.replace('\\', '/') for fn in files]
+    
+    return find_video_strings(files)
 
 
 #%% Function for rendering frames to video and vice-versa
 
 # 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].
@@ -222,7 +234,8 @@ def _video_to_frames_for_folder(relative_fn,input_folder,output_folder_base,ever
     """    
     
     input_fn_absolute = os.path.join(input_folder,relative_fn)
-    assert os.path.isfile(input_fn_absolute)
+    assert os.path.isfile(input_fn_absolute),\
+        'Could not find file {}'.format(input_fn_absolute)
 
     # Create the target output folder
     output_folder_video = os.path.join(output_folder_base,relative_fn)
@@ -244,6 +257,8 @@ def video_folder_to_frames(input_folder:str, output_folder_base:str,
     """
     For every video file in input_folder, create a folder within output_folder_base, and 
     render every frame of the video to .jpg in that folder.
+    
+    return frame_filenames_by_video,fs_by_video,input_files_full_paths
     """
     
     # Recursively enumerate video files
@@ -298,6 +313,9 @@ class FrameToVideoOptions:
     # zero-indexed
     nth_highest_confidence = 1
     
+    # 'error' or 'skip_with_warning'
+    non_video_behavior = 'error'
+    
     
 def frame_results_to_video_results(input_file,output_file,options:FrameToVideoOptions = None):
     """
@@ -327,7 +345,15 @@ def frame_results_to_video_results(input_file,output_file,options:FrameToVideoOp
         
         fn = im['file']
         video_name = os.path.dirname(fn)
-        assert is_video_file(video_name)
+        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':
+                print('Warning: {} is not a video file'.format(video_name))
+                continue
+            else:
+                raise ValueError('Unrecognized non-video handling behavior: {}'.format(
+                    options.non_video_behavior))
         video_to_frames[video_name].append(im)
     
     print('Found {} unique videos in {} frame-level results'.format(

md_utils/ct_utils.py

@@ -2,7 +2,7 @@
 #
 # ct_utils.py
 #
-# Utility functions that don't depend on other things in this repo.
+# Numeric/geometry utility functions
 #
 ########
 
@@ -260,3 +260,174 @@ def get_max_conf(im):
     if 'detections' in im and im['detections'] is not None and len(im['detections']) > 0:
         max_conf = _get_max_conf_from_detections(im['detections'])
     return max_conf
+
+
+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) )
+
+
+def rect_distance(r1, r2, format='x0y0x1y1'):
+    """
+    Minimum distance between two axis-aligned rectangles, each represented as 
+    (x0,y0,x1,y1) by default.
+    
+    Can also specify "format" as x0y0wh for MD-style bbox formatting (x0,y0,w,h).    
+    """
+    
+    assert format in ('x0y0x1y1','x0y0wh')
+    
+    if format == 'x0y0wh':
+        # Convert to x0y0x1y1 without modifying the original rectangles
+        r1 = [r1[0],r1[1],r1[0]+r1[2],r1[1]+r1[3]]
+        r2 = [r2[0],r2[1],r2[0]+r2[2],r2[1]+r2[3]]
+        
+    # https://stackoverflow.com/a/26178015
+    x1, y1, x1b, y1b = r1
+    x2, y2, x2b, y2b = r2
+    left = x2b < x1
+    right = x1b < x2
+    bottom = y2b < y1
+    top = y1b < y2
+    if top and left:
+        return point_dist((x1, y1b), (x2b, y2))
+    elif left and bottom:
+        return point_dist((x1, y1), (x2b, y2b))
+    elif bottom and right:
+        return point_dist((x1b, y1), (x2, y2b))
+    elif right and top:
+        return point_dist((x1b, y1b), (x2, y2))
+    elif left:
+        return x1 - x2b
+    elif right:
+        return x2 - x1b
+    elif bottom:
+        return y1 - y2b
+    elif top:
+        return y2 - y1b
+    else:
+        return 0.0
+
+
+def list_is_sorted(l):
+    """
+    Returns True if the list [l] is sorted, else False.
+    """
+    
+    return all(l[i] <= l[i+1] for i in range(len(l)-1))
+
+
+def split_list_into_fixed_size_chunks(L,n):
+    """
+    Split the list or tuple L into chunks of size n (allowing chunks of size n-1 if necessary,
+    i.e. len(L) does not have to be a multiple of 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, 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_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
+    r1 = [0,0,1,1]; r2 = [0,0,1,100]; assert rect_distance(r1,r2)==0
+    r1 = [0,0,1,1]; r2 = [1,1,2,2]; assert rect_distance(r1,r2)==0
+    r1 = [0,0,1,1]; r2 = [1.1,0,0,1.1]; assert abs(rect_distance(r1,r2)-.1) < 0.00001
+    
+    r1 = [0.4,0.8,10,22]; r2 = [100, 101, 200, 210.4]; assert abs(rect_distance(r1,r2)-119.753) < 0.001
+    r1 = [0.4,0.8,10,22]; r2 = [101, 101, 200, 210.4]; assert abs(rect_distance(r1,r2)-120.507) < 0.001    
+    r1 = [0.4,0.8,10,22]; r2 = [120, 120, 200, 210.4]; assert abs(rect_distance(r1,r2)-147.323) < 0.001