megadetector 5.0.23__py3-none-any.whl → 5.0.25__py3-none-any.whl

megadetector/postprocessing/create_crop_folder.py

@@ -0,0 +1,358 @@
+"""
+
+create_crop_folder.py
+
+Given a MegaDetector .json file and a folder of images, creates a new folder
+of images representing all above-threshold crops from the original folder.
+
+"""
+
+#%% Constants and imports
+
+import os
+import json
+from tqdm import tqdm
+
+from multiprocessing.pool import Pool, ThreadPool
+from collections import defaultdict
+from functools import partial
+
+from megadetector.utils.path_utils import insert_before_extension
+from megadetector.visualization.visualization_utils import crop_image
+from megadetector.visualization.visualization_utils import exif_preserving_save
+
+
+#%% Support classes
+
+class CreateCropFolderOptions:
+    """
+    Options used to parameterize create_crop_folder().
+    """
+    
+    def __init__(self):
+        
+        #: Confidence threshold determining which detections get written
+        self.confidence_threshold = 0.1
+        
+        #: Number of pixels to expand each crop
+        self.expansion = 0
+        
+        #: JPEG quality to use for saving crops (None for default)
+        self.quality = 95
+        
+        #: Whether to overwrite existing images
+        self.overwrite = True
+        
+        #: Number of concurrent workers
+        self.n_workers = 8
+        
+        #: Whether to use processes ('process') or threads ('thread') for parallelization
+        self.pool_type = 'thread'
+                
+          
+#%% Support functions
+
+def _get_crop_filename(image_fn,crop_id):
+    """
+    Generate crop filenames in a consistent way.
+    """
+    if isinstance(crop_id,int):
+        crop_id = str(crop_id).zfill(3)
+    assert isinstance(crop_id,str)
+    return insert_before_extension(image_fn,'crop_' + crop_id)
+
+
+def _generate_crops_for_single_image(crops_this_image,
+                                     input_folder,
+                                     output_folder,
+                                     options):
+    """
+    Generate all the crops required for a single image.
+    """
+    if len(crops_this_image) == 0:
+        return
+    
+    image_fn_relative = crops_this_image[0]['image_fn_relative']    
+    input_fn_abs = os.path.join(input_folder,image_fn_relative)
+    assert os.path.isfile(input_fn_abs)
+    
+    detections_to_crop = [c['detection'] for c in crops_this_image]
+    
+    cropped_images = crop_image(detections_to_crop,
+                                input_fn_abs,
+                                confidence_threshold=0,
+                                expansion=options.expansion)
+    
+    assert len(cropped_images) == len(crops_this_image)
+    
+    # i_crop = 0; crop_info = crops_this_image[0]
+    for i_crop,crop_info in enumerate(crops_this_image):
+        
+        assert crop_info['image_fn_relative'] == image_fn_relative
+        crop_filename_relative = _get_crop_filename(image_fn_relative, crop_info['crop_id'])        
+        crop_filename_abs = os.path.join(output_folder,crop_filename_relative).replace('\\','/')
+        
+        if os.path.isfile(crop_filename_abs) and not options.overwrite:
+            continue
+         
+        cropped_image = cropped_images[i_crop]            
+        os.makedirs(os.path.dirname(crop_filename_abs),exist_ok=True)            
+        exif_preserving_save(cropped_image,crop_filename_abs,quality=options.quality)
+    
+    # ...for each crop
+
+
+#%% Main function
+
+def crop_results_to_image_results(image_results_file_with_crop_ids,
+                                  crop_results_file,
+                                  output_file):
+    """
+    This function is intended to be run after you have:
+        
+        1. Run MegaDetector on a folder
+        2. Generated a crop folder using create_crop_folder
+        3. Run a species classifier on those crops
+    
+    This function will take the crop-level results and transform them back
+    to the original images.
+        
+    Args:
+        image_results_file_with_crop_ids (str): results file for the original images,
+            containing crop IDs, likely generated via create_crop_folder.
+        crop_results_file (str): results file for the crop folder
+        output_file (str): ouptut .json file, containing crop-level classifications
+            mapped back to the image level
+    """
+    
+    ##%% Validate inputs
+    
+    assert os.path.isfile(image_results_file_with_crop_ids), \
+        'Could not find image-level input file {}'.format(image_results_file_with_crop_ids)
+    assert os.path.isfile(crop_results_file), \
+        'Could not find crop results file {}'.format(crop_results_file)
+    os.makedirs(os.path.dirname(output_file),exist_ok=True)
+        
+    
+    ##%% Read input files
+    
+    with open(image_results_file_with_crop_ids,'r') as f:
+        image_results_with_crop_ids = json.load(f)
+    with open(crop_results_file,'r') as f:
+        crop_results = json.load(f)
+    
+    assert crop_results['detection_categories'] == \
+        image_results_with_crop_ids['detection_categories'], \
+            'Crop results and image-level results use different detection categories'
+        
+    crop_filename_to_results = {}
+    
+    # im = crop_results['images'][0]
+    for im in crop_results['images']:
+        crop_filename_to_results[im['file']] = im
+    
+    image_results_with_crop_ids['classification_categories'] = \
+        crop_results['classification_categories']
+    
+        
+    ##%% Read classifications from crop results
+    
+    # im = image_results_with_crop_ids['images'][0]
+    for im in tqdm(image_results_with_crop_ids['images']):
+        
+        if 'detections' not in im or im['detections'] is None:
+            continue
+        
+        for det in im['detections']:
+        
+            if 'classifications' in det:
+                del det['classifications']
+                
+            if 'crop_id' in det:
+                crop_filename_relative = det['crop_filename_relative']
+                assert crop_filename_relative in crop_filename_to_results, \
+                    'Crop lookup error'
+                crop_results_this_detection = crop_filename_to_results[crop_filename_relative]
+                assert crop_results_this_detection['file'] == crop_filename_relative
+                assert len(crop_results_this_detection['detections']) == 1
+                assert crop_results_this_detection['detections'][0]['conf'] == det['conf']
+                assert crop_results_this_detection['detections'][0]['category'] == det['category']
+                assert crop_results_this_detection['detections'][0]['bbox'] == [0,0,1,1]
+                det['classifications'] = crop_results_this_detection['detections'][0]['classifications']
+                
+        # ...for each detection
+    
+    # ...for each image        
+    
+    
+    ##%% Write output file
+    
+    with open(output_file,'w') as f:
+        json.dump(image_results_with_crop_ids,f,indent=1)
+
+# ...def crop_results_to_image_results(...)
+
+
+def create_crop_folder(input_file,
+                       input_folder,
+                       output_folder,
+                       output_file=None,
+                       crops_output_file=None,
+                       options=None):
+    """
+    Given a MegaDetector .json file and a folder of images, creates a new folder
+    of images representing all above-threshold crops from the original folder.
+    
+    Optionally writes a new .json file that attaches unique IDs to each detection.
+    
+    Args:
+        input_file (str): MD-formatted .json file to process
+        input_folder (str): Input image folder
+        output_folder (str): Output (cropped) image folder
+        output_file (str, optional): new .json file that attaches unique IDs to each detection.
+        crops_output_file (str, optional): new .json file that includes whole-image detections
+            for each of the crops, using confidence values from the original results
+        options (CreateCropFolderOptions, optional): crop parameters    
+    """
+        
+    ## Validate options, prepare output folders
+    
+    if options is None:
+        options = CreateCropFolderOptions()
+
+    assert os.path.isfile(input_file), 'Input file {} not found'.format(input_file)
+    assert os.path.isdir(input_folder), 'Input folder {} not found'.format(input_folder)
+    os.makedirs(output_folder,exist_ok=True)
+    os.makedirs(os.path.dirname(output_file),exist_ok=True)
+    
+    
+    ##%% Read input
+    
+    with open(input_file,'r') as f:
+        detection_results = json.load(f)
+       
+        
+    ##%% Make a list crops that we need to create
+    
+    # Maps input images to list of dicts, with keys 'crop_id','detection'
+    image_fn_relative_to_crops = defaultdict(list)
+    n_crops = 0
+    
+    # im = detection_results['images'][0]
+    for i_image,im in enumerate(detection_results['images']):
+        
+        if 'detections' not in im or im['detections'] is None or len(im['detections']) == 0:
+            continue
+        
+        detections_this_image = im['detections']
+        
+        image_fn_relative = im['file']
+        
+        for i_detection,det in enumerate(detections_this_image):
+            
+            if det['conf'] > options.confidence_threshold:
+                            
+                det['crop_id'] = i_detection
+                
+                crop_info = {'image_fn_relative':image_fn_relative,
+                             'crop_id':i_detection,
+                             'detection':det}
+                
+                crop_filename_relative = _get_crop_filename(image_fn_relative, 
+                                                            crop_info['crop_id'])
+                det['crop_filename_relative'] = crop_filename_relative
+
+                image_fn_relative_to_crops[image_fn_relative].append(crop_info)
+                n_crops += 1
+                
+    # ...for each input image   
+
+    print('Prepared a list of {} crops from {} of {} input images'.format(
+        n_crops,len(image_fn_relative_to_crops),len(detection_results['images'])))
+        
+    
+    ##%% Generate crops
+        
+    if options.n_workers <= 1:
+                
+        # image_fn_relative = next(iter(image_fn_relative_to_crops))
+        for image_fn_relative in tqdm(image_fn_relative_to_crops.keys()):
+            crops_this_image = image_fn_relative_to_crops[image_fn_relative]            
+            _generate_crops_for_single_image(crops_this_image=crops_this_image,
+                                             input_folder=input_folder,
+                                             output_folder=output_folder,
+                                             options=options)
+                
+    else:
+        
+        print('Creating a {} pool with {} workers'.format(options.pool_type,options.n_workers))
+
+        if options.pool_type == 'thread':
+            pool = ThreadPool(options.n_workers)
+        else:
+            assert options.pool_type == 'process'
+            pool = Pool(options.n_workers)
+        
+        # Each element in this list is the list of crops for a single image
+        crop_lists = list(image_fn_relative_to_crops.values())
+        
+        with tqdm(total=len(image_fn_relative_to_crops)) as pbar:
+            for i,_ in enumerate(pool.imap_unordered(partial(
+                        _generate_crops_for_single_image,
+                            input_folder=input_folder,
+                            output_folder=output_folder,
+                            options=options),
+                        crop_lists)):
+                pbar.update()
+
+    # ...if we're using parallel processing    
+    
+    ##%% Write output file
+    
+    if output_file is not None:
+        with open(output_file,'w') as f:
+            json.dump(detection_results,f,indent=1)
+        
+    if crops_output_file is not None:
+        
+        original_images = detection_results['images']
+        
+        detection_results_cropped = detection_results
+        detection_results_cropped['images'] = []
+        
+        # im = original_images[0]
+        for im in original_images:
+            
+            if 'detections' not in im or im['detections'] is None or len(im['detections']) == 0:
+                continue
+            
+            detections_this_image = im['detections']            
+            image_fn_relative = im['file']
+            
+            for i_detection,det in enumerate(detections_this_image):
+                
+                if 'crop_id' in det:
+                    im_out = {}
+                    im_out['file'] = det['crop_filename_relative']
+                    det_out = {}
+                    det_out['category'] = det['category']
+                    det_out['conf'] = det['conf']
+                    det_out['bbox'] = [0, 0, 1, 1]
+                    im_out['detections'] = [det_out]
+                    detection_results_cropped['images'].append(im_out)
+            
+                # ...if we need to include this crop in the new .json file
+                
+            # ...for each crop
+            
+        # ...for each original image
+        
+        with open(crops_output_file,'w') as f:
+            json.dump(detection_results_cropped,f,indent=1)
+    
+# ...def create_crop_folder()
+
+
+#%% Command-line driver
+
+# TODO

megadetector/postprocessing/md_to_labelme.py

@@ -25,8 +25,8 @@ from multiprocessing.pool import ThreadPool
 from functools import partial
 
 from megadetector.visualization.visualization_utils import open_image
-from megadetector.utils.ct_utils import truncate_float
-from megadetector.detection.run_detector import DEFAULT_DETECTOR_LABEL_MAP
+from megadetector.utils.ct_utils import round_float
+from megadetector.detection.run_detector import DEFAULT_DETECTOR_LABEL_MAP, FAILURE_IMAGE_OPEN
 
 output_precision = 3
 default_confidence_threshold = 0.15
@@ -92,10 +92,10 @@ def get_labelme_dict_for_image(im,image_base_name=None,category_id_to_name=None,
         # MD boxes are [x_min, y_min, width_of_box, height_of_box] (relative)
         # 
         # labelme boxes are [[x0,y0],[x1,y1]] (absolute)
-        x0 = truncate_float(det['bbox'][0] * im['width'],output_precision)
-        y0 = truncate_float(det['bbox'][1] * im['height'],output_precision)
-        x1 = truncate_float(x0 + det['bbox'][2] * im['width'],output_precision)
-        y1 = truncate_float(y0 + det['bbox'][3] * im['height'],output_precision)
+        x0 = round_float(det['bbox'][0] * im['width'],output_precision)
+        y0 = round_float(det['bbox'][1] * im['height'],output_precision)
+        x1 = round_float(x0 + det['bbox'][2] * im['width'],output_precision)
+        y1 = round_float(y0 + det['bbox'][3] * im['height'],output_precision)
         shape['points'] = [[x0,y0],[x1,y1]]
         output_dict['shapes'].append(shape)
     
@@ -210,7 +210,7 @@ def md_to_labelme(results_file,image_base,confidence_threshold=None,
                     print('Warning: cannot open image {}, treating as a failure during inference'.format(
                         im_full_path))
                     if 'failure' not in im:
-                        im['failure'] = 'Failure image access'        
+                        im['failure'] = FAILURE_IMAGE_OPEN
     
             # ...if we need to read w/h information
             

megadetector/postprocessing/md_to_wi.py

@@ -0,0 +1,40 @@
+"""
+
+md_to_wi.py
+
+Converts the MD .json format to the WI predictions.json format.
+
+"""
+
+#%% Imports and constants
+
+import sys
+import argparse
+from megadetector.utils.wi_utils import generate_predictions_json_from_md_results
+
+
+#%% Command-line driver
+
+def main():
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('md_results_file', action='store', type=str, 
+                        help='output file in MD format to convert')
+    parser.add_argument('predictions_json_file', action='store', type=str, 
+                        help='.json file to write in predictions.json format')
+    parser.add_argument('--base_folder', action='store', type=str, default=None, 
+                        help='folder name to prepend to each path in md_results_file, ' + \
+                             'to convert relative paths to absolute paths.')
+
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+            
+    args = parser.parse_args()
+    
+    generate_predictions_json_from_md_results(args.md_results_file,
+                                              args.predictions_json_file,
+                                              base_folder=None)
+
+if __name__ == '__main__':    
+    main()

megadetector/postprocessing/merge_detections.py

@@ -9,7 +9,7 @@ results file from MDv5a.
 Detection categories must be the same in both files; if you want to first remap
 one file's category mapping to be the same as another's, see remap_detection_categories.
 
-If you want to literally merge two .json files, see combine_api_outputs.py.
+If you want to literally merge two .json files, see combine_batch_outputs.py.
 
 """
 

megadetector/postprocessing/postprocess_batch_results.py

@@ -211,6 +211,9 @@ class PostProcessingOptions:
         #    format('https://megadetector.readthedocs.io')
         self.footer_text = ''
 
+        #: Character encoding to use when writing the index HTML html
+        self.output_html_encoding = None
+        
     # ...__init__()
     
 # ...PostProcessingOptions
@@ -778,7 +781,8 @@ def _render_image_no_gt(file_info,detection_categories_to_results_name,
             if det['conf'] > max_conf:
                 max_conf = det['conf']
 
-            if ('classifications' in det) and (len(det['classifications']) > 0):
+            if ('classifications' in det) and (len(det['classifications']) > 0) and \
+                (res != 'non_detections'):
 
                 # This is a list of [class,confidence] pairs, sorted by confidence
                 classifications = det['classifications']
@@ -1522,7 +1526,8 @@ def process_batch_results(options):
         # Close body and html tags
         index_page += '{}</body></html>'.format(options.footer_text)
         output_html_file = os.path.join(output_dir, 'index.html')
-        with open(output_html_file, 'w') as f:
+        with open(output_html_file, 'w', 
+                  encoding=options.output_html_encoding) as f:
             f.write(index_page)
 
         print('Finished writing html to {}'.format(output_html_file))
@@ -1717,7 +1722,7 @@ def process_batch_results(options):
         <p>Model version: {}</p>
         </div>
         
-        <h3>Sample images</h3>\n
+        <h3>Detection results</h3>\n
         <div class="contentdiv">\n""".format(
             style_header, job_name_string, image_count, len(detections_df), confidence_threshold_string,
             almost_detection_string, model_version_string)
@@ -1778,7 +1783,8 @@ def process_batch_results(options):
         index_page += '</div>\n'
 
         if has_classification_info:
-            index_page += '<h3>Images of detected classes</h3>'
+            
+            index_page += '<h3>Species classification results</h3>'
             index_page += '<p>The same image might appear under multiple classes ' + \
                 'if multiple species were detected.</p>\n'
             index_page += '<p>Classifications with confidence less than {:.1%} confidence are considered "unreliable".</p>\n'.format(
@@ -1806,7 +1812,8 @@ def process_batch_results(options):
 
         index_page += '{}</body></html>'.format(options.footer_text)
         output_html_file = os.path.join(output_dir, 'index.html')
-        with open(output_html_file, 'w') as f:
+        with open(output_html_file, 'w', 
+                  encoding=options.output_html_encoding) as f:
             f.write(index_page)
 
         print('Finished writing html to {}'.format(output_html_file))

megadetector/postprocessing/separate_detections_into_folders.py

@@ -88,6 +88,7 @@ from tqdm import tqdm
 from megadetector.utils.ct_utils import args_to_object, is_float
 from megadetector.detection.run_detector import get_typical_confidence_threshold_from_results
 from megadetector.visualization import visualization_utils as vis_utils
+from megadetector.visualization.visualization_utils import blur_detections
 
 friendly_folder_names = {'animal':'animals','person':'people','vehicle':'vehicles'}
 
@@ -188,6 +189,11 @@ class SeparateDetectionsIntoFoldersOptions:
         #: Do not set explicitly; this gets loaded from [results_file]
         self.category_id_to_category_name = None
         
+        #: List of category names for which we should blur detections, most commonly ['person']
+        #:
+        #: Can also be a comma-separated list.        
+        self.category_names_to_blur = None
+        
     # ...__init__()
     
 # ...class SeparateDetectionsIntoFoldersOptions        
@@ -369,10 +375,10 @@ def _process_detections(im,options):
         return
         
     # At this point, this image is getting copied; we may or may not also need to
-    # draw bounding boxes.
+    # draw bounding boxes or blur pixels.
     
-    # Do a simple copy operation if we don't need to render any boxes
-    if (not options.render_boxes) or \
+    # Do a simple copy operation if we don't need to manipulate the images (render boxes, blur pixels)
+    if (not options.render_boxes and (options.category_names_to_blur is None)) or \
         (categories_above_threshold is None) or \
         (len(categories_above_threshold) == 0):
         
@@ -386,6 +392,24 @@ def _process_detections(im,options):
         # Open the source image
         pil_image = vis_utils.load_image(source_path)
         
+        # Blur regions in the image if necessary
+        category_names_to_blur = options.category_names_to_blur
+        
+        if category_names_to_blur is not None:
+            
+            if isinstance(category_names_to_blur,str):
+                category_names_to_blur = category_names_to_blur.split(',')
+                category_names_to_blur = [s.strip() for s in category_names_to_blur]
+        
+            detections_to_blur = []
+            for d in detections:
+                category_name = options.category_id_to_category_name[d['category']]
+                category_threshold = options.category_name_to_threshold[category_name]
+                if (d['conf'] >= category_threshold) and (category_name in category_names_to_blur):
+                    detections_to_blur.append(d)
+            if len(detections_to_blur) > 0:
+                blur_detections(pil_image,detections_to_blur)
+                
         # Render bounding boxes for each category separately, because
         # we allow different thresholds for each category.
         
@@ -447,9 +471,11 @@ def separate_detections_into_folders(options):
     # Input validation
     
     # Currently we don't support moving (instead of copying) when we're also rendering
-    # bounding boxes.
+    # bounding boxes or blurring humans.
     assert not (options.render_boxes and options.move_images), \
         'Cannot specify both render_boxes and move_images'
+    assert not ((options.category_names_to_blur is not None) and options.move_images), \
+        'Cannot specify both category_names_to_blur and move_images'
                 
     # Create output folder if necessary
     if (os.path.isdir(options.base_output_folder)) and \
@@ -687,6 +713,8 @@ def main():
                         help='Box expansion (in pixels) for rendering, only meaningful if ' + \
                              'using render_boxes (defaults to {})'.format(
                              default_box_expansion))
+    parser.add_argument('--category_names_to_blur', type=str, default=None,
+                        help='Comma-separated list of category names to blur (or a single category name, e.g. "person")')
         
     if len(sys.argv[1:])==0:
         parser.print_help()

megadetector/postprocessing/validate_batch_results.py

@@ -50,6 +50,9 @@ class ValidateBatchResultsOptions:
         
         #: Enable additional debug output
         self.verbose = False
+        
+        #: Should we raise errors immediately (vs. just catching and reporting)?
+        self.raise_errors = False
     
 # ...class ValidateBatchResultsOptions
 
@@ -71,8 +74,7 @@ def validate_batch_results(json_filename,options=None):
         the loaded data.  The "validation_results" dict contains fields called "errors", "warnings",
         and "filename".  "errors" and "warnings" are lists of strings, although "errors" will never
         be longer than N=1, since validation fails at the first error.
-        
-        
+            
     """
     
     if options is None:
@@ -223,8 +225,11 @@ def validate_batch_results(json_filename,options=None):
                     'Warning: non-standard key {} present at file level'.format(k))                
         
     except Exception as e:
-        
-        validation_results['errors'].append(str(e))
+                
+        if options.raise_errors:
+            raise
+        else:
+            validation_results['errors'].append(str(e))
         
     # ...try/except