megadetector 5.0.24__py3-none-any.whl → 5.0.26__py3-none-any.whl

megadetector/data_management/cct_json_utils.py

@@ -300,7 +300,10 @@ class SequenceOptions:
     def __init__(self):
         #: Images separated by <= this duration will be grouped into the same sequence.
         self.episode_interval_seconds = 60.0
-
+        
+        #: How to handle invalid datetimes: 'error' or 'none'
+        self.datetime_conversion_failure_behavior = 'none'
+        
     
 #%% Functions
 
@@ -445,7 +448,17 @@ def create_sequences(image_info,options=None):
         raise ValueError('Unrecognized type for [image_info]')
         
     # Modifies the images in place
-    _ = parse_datetimes_from_cct_image_list(image_info)
+    _ = parse_datetimes_from_cct_image_list(image_info, 
+            conversion_failure_behavior=options.datetime_conversion_failure_behavior)
+    
+    n_invalid_datetimes = 0
+    for im in image_info:
+        if not isinstance(im['datetime'],datetime.datetime):
+            assert im['datetime'] is None, 'At this point, datetimes should be valid or None'
+            n_invalid_datetimes += 1
+    if n_invalid_datetimes > 0:
+        print('Warning: {} of {} images have invalid datetimes'.format(
+            n_invalid_datetimes,len(image_info)))
     
     # Find all unique locations
     locations = set()

megadetector/data_management/coco_to_yolo.py

@@ -47,6 +47,9 @@ def write_yolo_dataset_file(yolo_dataset_file,
         class_list (list or str): an ordered list of class names (the first item will be class 0, 
             etc.), or the name of a text file containing an ordered list of class names (one per 
             line, starting from class zero).
+        train_folder_relative (str, optional): train folder name, used only to populate dataset.yaml
+        val_folder_relative (str, optional): val folder name, used only to populate dataset.yaml
+        test_folder_relative (str, optional): test folder name, used only to populate dataset.yaml        
     """
     
     # Read class names
@@ -97,7 +100,7 @@ def coco_to_yolo(input_image_folder,
                  category_names_to_exclude=None,
                  category_names_to_include=None,
                  write_output=True,
-                 flatten_paths=True):
+                 flatten_paths=False):
     """
     Converts a COCO-formatted dataset to a YOLO-formatted dataset, optionally flattening the 
     dataset to a single folder in the process.
@@ -116,17 +119,21 @@ def coco_to_yolo(input_image_folder,
             images are left alone.
         source_format (str, optional): can be 'coco' (default) or 'coco_camera_traps'.  The only difference
             is that when source_format is 'coco_camera_traps', we treat an image with a non-bbox
-            annotation with a category id of 0 as a special case, i.e. that's how an empty image
-            is indicated.  The original COCO standard is a little ambiguous on this issue.  If
-            source_format is 'coco', we either treat images as empty or error, depending on the value
-            of [allow_empty_annotations].  [allow_empty_annotations] has no effect if source_format is
-            'coco_camera_traps'.
+            annotation as a special case, i.e. that's how an empty image is indicated.  The original 
+            COCO standard is a little ambiguous on this issue.  If source_format is 'coco', we 
+            either treat images as empty or error, depending on the value of [allow_empty_annotations].
+            [allow_empty_annotations] has no effect if source_format is 'coco_camera_traps'.
+        overwrite_images (bool, optional): over-write images in the output folder if they exist
         create_image_and_label_folder (bool, optional): whether to create separate folders called 'images' and
             'labels' in the YOLO output folder.  If create_image_and_label_folders is False, 
             a/b/c/image001.jpg will become a#b#c#image001.jpg, and the corresponding text file will 
             be a#b#c#image001.txt.  If create_image_and_label_folders is True, a/b/c/image001.jpg will become 
             images/a#b#c#image001.jpg, and the corresponding text file will be 
             labels/a#b#c#image001.txt.    
+        class_file_name (str, optional): .txt file (relative to the output folder) that we should 
+            populate with a list of classes (or None to omit)
+        allow_empty_annotations (bool, optional): if this is False and [source_format] is 'coco', 
+            we'll error on annotations that have no 'bbox' field
         clip_boxes (bool, optional): whether to clip bounding box coordinates to the range [0,1] before
             converting to YOLO xywh format
         image_id_to_output_image_json_file (str, optional): an optional *output* file, to which we will write
@@ -139,12 +146,14 @@ def coco_to_yolo(input_image_folder,
         category_names_to_exclude (str, optional): category names that should not be represented in the
             YOLO output; only impacts annotations, does not prevent copying images.  There's almost no reason
             you would want to specify this and [category_names_to_include]. 
-        category_names_to_include (str, optional): allow-list of category names that should be represented in the
-            YOLO output; only impacts annotations, does not prevent copying images.  There's almost no reason
-            you would want to specify this and [category_names_to_exclude]. 
+        category_names_to_include (str, optional): allow-list of category names that should be represented 
+            in the YOLO output; only impacts annotations, does not prevent copying images.  There's almost 
+            no reason you would want to specify this and [category_names_to_exclude]. 
         write_output (bool, optional): determines whether we actually copy images and write annotations;
             setting this to False mostly puts this function in "dry run" "mode.  The class list
             file is written regardless of the value of write_output.
+        flatten_paths (bool, optional): replace /'s in image filenames with [path_replacement_char],
+            which ensures that the output folder is a single flat folder.
     
     Returns:
         dict: information about the coco --> yolo mapping, containing at least the fields:
@@ -313,9 +322,9 @@ def coco_to_yolo(input_image_folder,
                     
                     elif source_format == 'coco_camera_traps':
                         
-                        # We allow empty bbox lists in COCO camera traps; this is typically a negative
-                        # example in a dataset that has bounding boxes, and 0 is typically the empty 
-                        # category.
+                        # We allow empty bbox lists in COCO camera traps files; this is typically a 
+                        # negative example in a dataset that has bounding boxes, and 0 is typically 
+                        # the empty category, which is typically 0.
                         if ann['category_id'] != 0:
                             if not printed_empty_annotation_warning:
                                 printed_empty_annotation_warning = True
@@ -429,13 +438,14 @@ def coco_to_yolo(input_image_folder,
     
     print('Generating class list')
     
-    class_list_filename = os.path.join(output_folder,class_file_name)
-    with open(class_list_filename, 'w') as f:
-        print('Writing class list to {}'.format(class_list_filename))
-        for i_class in range(0,len(yolo_id_to_name)):
-            # Category IDs should range from 0..N-1
-            assert i_class in yolo_id_to_name
-            f.write(yolo_id_to_name[i_class] + '\n')
+    if class_file_name is not None:
+        class_list_filename = os.path.join(output_folder,class_file_name)
+        with open(class_list_filename, 'w') as f:
+            print('Writing class list to {}'.format(class_list_filename))
+            for i_class in range(0,len(yolo_id_to_name)):
+                # Category IDs should range from 0..N-1
+                assert i_class in yolo_id_to_name
+                f.write(yolo_id_to_name[i_class] + '\n')
     
     if image_id_to_output_image_json_file is not None:
         print('Writing image ID mapping to {}'.format(image_id_to_output_image_json_file))
@@ -457,6 +467,9 @@ def coco_to_yolo(input_image_folder,
         
     source_image_to_dest_image = {}
     
+    label_files_written = []
+    n_boxes_written = 0
+    
     # TODO: parallelize this loop
     #
     # output_info = images_to_copy[0]
@@ -471,6 +484,7 @@ def coco_to_yolo(input_image_folder,
         
         source_image_to_dest_image[source_image] = dest_image
         
+        # Copy the image if necessary
         if write_output:
             
             os.makedirs(os.path.dirname(dest_image),exist_ok=True)        
@@ -482,17 +496,24 @@ def coco_to_yolo(input_image_folder,
             if (not os.path.isfile(dest_image)) or (overwrite_images):
                 shutil.copyfile(source_image,dest_image)
         
-            bboxes = output_info['bboxes']        
+        bboxes = output_info['bboxes']        
+        
+        # Write the annotation file if necessary
+        #
+        # Only write an annotation file if there are bounding boxes.  Images with 
+        # no .txt files are treated as hard negatives, at least by YOLOv5:
+        #
+        # https://github.com/ultralytics/yolov5/issues/3218
+        #
+        # I think this is also true for images with empty .txt files, but 
+        # I'm using the convention suggested on that issue, i.e. hard 
+        # negatives are expressed as images without .txt files.
+        if len(bboxes) > 0:
             
-            # Only write an annotation file if there are bounding boxes.  Images with 
-            # no .txt files are treated as hard negatives, at least by YOLOv5:
-            #
-            # https://github.com/ultralytics/yolov5/issues/3218
-            #
-            # I think this is also true for images with empty .txt files, but 
-            # I'm using the convention suggested on that issue, i.e. hard 
-            # negatives are expressed as images without .txt files.
-            if len(bboxes) > 0:
+            n_boxes_written += len(bboxes)
+            label_files_written.append(dest_txt)
+            
+            if write_output:
                 
                 with open(dest_txt,'w') as f:
                     
@@ -501,8 +522,7 @@ def coco_to_yolo(input_image_folder,
                         assert len(bbox) == 5
                         s = '{} {} {} {} {}'.format(bbox[0],bbox[1],bbox[2],bbox[3],bbox[4])
                         f.write(s + '\n')
-                        
-        # ...if we're actually writing output
+                            
         
     # ...for each image
     
@@ -510,6 +530,8 @@ def coco_to_yolo(input_image_folder,
     coco_to_yolo_info['class_list_filename'] = class_list_filename
     coco_to_yolo_info['source_image_to_dest_image'] = source_image_to_dest_image
     coco_to_yolo_info['coco_id_to_yolo_id'] = coco_id_to_yolo_id
+    coco_to_yolo_info['label_files_written'] = label_files_written
+    coco_to_yolo_info['n_boxes_written'] = n_boxes_written
     
     return coco_to_yolo_info
 

megadetector/data_management/databases/combine_coco_camera_traps_files.py

@@ -24,8 +24,10 @@ import sys
 
 #%% Merge functions
 
-def combine_cct_files(input_files, output_file=None, require_uniqueness=True,
-                      filename_prefixes=None):                             
+def combine_cct_files(input_files, 
+                      output_file=None, 
+                      require_uniqueness=True,
+                      filename_prefixes=None):
     """
     Merges the list of COCO Camera Traps files [input_files] into a single
     dictionary, optionally writing the result to [output_file].
@@ -33,8 +35,10 @@ def combine_cct_files(input_files, output_file=None, require_uniqueness=True,
     Args:
         input_files (list): paths to CCT .json files
         output_file (str, optional): path to write merged .json file
-        require_uniqueness (bool): whether to require that the images in
+        require_uniqueness (bool, optional): whether to require that the images in
             each input_dict be unique
+        filename_prefixes (dict, optional): dict mapping input filenames to strings
+            that should be prepended to image filenames from that source            
     
     Returns:
         dict: the merged COCO-formatted .json dict

megadetector/data_management/databases/integrity_check_json_db.py

@@ -327,7 +327,7 @@ def integrity_check_json_db(jsonFile, options=None):
                 
         for i_image,result in enumerate(results):
             if result is not None:
-                validation_errors.append(images[i_image]['file_name'],result)
+                validation_errors.append((images[i_image]['file_name'],result))
                             
     # ...for each image
     
@@ -393,7 +393,7 @@ def integrity_check_json_db(jsonFile, options=None):
             elif image['_count'] > 1:
                 nMultiAnnotated += 1
                 
-        print('Found {} unannotated images, {} images with multiple annotations'.format(
+        print('\nFound {} unannotated images, {} images with multiple annotations'.format(
                 nUnannotated,nMultiAnnotated))
         
         if (len(base_dir) > 0) and options.bFindUnusedImages:

megadetector/data_management/lila/add_locations_to_island_camera_traps.py

@@ -20,78 +20,82 @@ preview_folder = os.path.expanduser('~/tmp/island_conservation_preview')
 image_directory = os.path.expanduser('~/data/icct/public/')
 
 
-#%% Read input file
+#%% Prevent imports during testing
 
-with open(input_fn,'r') as f:
-    d = json.load(f)
-    
-d['info']
-d['info']['version'] = '1.01'
-
-
-#%% Find locations
-
-images = d['images']
-
-locations = set()
+if False:
 
-for i_image,im in tqdm(enumerate(images),total=len(images)):
-    tokens_fn = im['file_name'].split('/')
-    tokens_id = im['id'].split('_')
-    assert tokens_fn[0] == tokens_id[0]
-    assert tokens_fn[1] == tokens_id[1]
-    location = tokens_fn[0] + '_' + tokens_fn[1]
-    im['location'] = location
-    locations.add(location)
-
-locations = sorted(list(locations))
+    #%% Read input file
     
-for s in locations:
-    print(s)
+    with open(input_fn,'r') as f:
+        d = json.load(f)
+        
+    d['info']
+    d['info']['version'] = '1.01'
     
     
-#%% Write output file
-
-with open(output_fn,'w') as f:
-    json.dump(d,f,indent=1)
+    #%% Find locations
     
-
-#%% Validate .json files
-
-from megadetector.data_management.databases import integrity_check_json_db
-
-options = integrity_check_json_db.IntegrityCheckOptions()
-options.baseDir = image_directory
-options.bCheckImageSizes = False
-options.bCheckImageExistence = True
-options.bFindUnusedImages = True
-
-sorted_categories, data, error_info = integrity_check_json_db.integrity_check_json_db(output_fn, options)
-
-
-#%% Preview labels
-
-from megadetector.visualization import visualize_db
-
-viz_options = visualize_db.DbVizOptions()
-viz_options.num_to_visualize = 2000
-viz_options.trim_to_images_with_bboxes = False
-viz_options.add_search_links = False
-viz_options.sort_by_filename = False
-viz_options.parallelize_rendering = True
-viz_options.classes_to_exclude = ['test']
-html_output_file, image_db = visualize_db.visualize_db(db_path=output_fn,
-                                                         output_dir=preview_folder,
-                                                         image_base_dir=image_directory,
-                                                         options=viz_options)
-
-from megadetector.utils import path_utils
-path_utils.open_file(html_output_file)
-
-
-#%% Zip output file
-
-from megadetector.utils.path_utils import zip_file
-
-zip_file(output_fn, verbose=True)
-assert os.path.isfile(output_fn + '.zip')
+    images = d['images']
+    
+    locations = set()
+    
+    for i_image,im in tqdm(enumerate(images),total=len(images)):
+        tokens_fn = im['file_name'].split('/')
+        tokens_id = im['id'].split('_')
+        assert tokens_fn[0] == tokens_id[0]
+        assert tokens_fn[1] == tokens_id[1]
+        location = tokens_fn[0] + '_' + tokens_fn[1]
+        im['location'] = location
+        locations.add(location)
+    
+    locations = sorted(list(locations))
+        
+    for s in locations:
+        print(s)
+        
+        
+    #%% Write output file
+    
+    with open(output_fn,'w') as f:
+        json.dump(d,f,indent=1)
+        
+    
+    #%% Validate .json files
+    
+    from megadetector.data_management.databases import integrity_check_json_db
+    
+    options = integrity_check_json_db.IntegrityCheckOptions()
+    options.baseDir = image_directory
+    options.bCheckImageSizes = False
+    options.bCheckImageExistence = True
+    options.bFindUnusedImages = True
+    
+    sorted_categories, data, error_info = integrity_check_json_db.integrity_check_json_db(output_fn, options)
+    
+    
+    #%% Preview labels
+    
+    from megadetector.visualization import visualize_db
+    
+    viz_options = visualize_db.DbVizOptions()
+    viz_options.num_to_visualize = 2000
+    viz_options.trim_to_images_with_bboxes = False
+    viz_options.add_search_links = False
+    viz_options.sort_by_filename = False
+    viz_options.parallelize_rendering = True
+    viz_options.classes_to_exclude = ['test']
+    html_output_file, image_db = visualize_db.visualize_db(db_path=output_fn,
+                                                             output_dir=preview_folder,
+                                                             image_base_dir=image_directory,
+                                                             options=viz_options)
+    
+    from megadetector.utils import path_utils
+    path_utils.open_file(html_output_file)
+    
+    
+    #%% Zip output file
+    
+    from megadetector.utils.path_utils import zip_file
+    
+    zip_file(output_fn, verbose=True)
+    assert os.path.isfile(output_fn + '.zip')

megadetector/data_management/lila/add_locations_to_nacti.py

@@ -21,127 +21,131 @@ input_file = r'd:\lila\nacti\nacti_metadata.json.1.13\nacti_metadata.json'
 output_file = r'g:\temp\nacti_metadata.1.14.json'
 
 
-#%% Read metadata
+#%% Prevent execution during testing
 
-with open(input_file,'r') as f:
-    d = json.load(f)
-    
-assert d['info']['version'] == 1.13
-
-
-#%% Map images to locations (according to the metadata)
-
-file_name_to_original_location = {}
-
-# im = dataset_labels['images'][0]
-for im in tqdm(d['images']):
-    file_name_to_original_location[im['file_name']] = im['location']
-
-original_locations = set(file_name_to_original_location.values())
-
-print('Found {} locations in the original metadata:'.format(len(original_locations)))
-for loc in original_locations:
-    print('[{}]'.format(loc))
+if False:
 
-
-#%% Map images to new locations
-
-def path_to_location(relative_path):
-    
-    relative_path = relative_path.replace('\\','/')
-    if relative_path in file_name_to_original_location:
-        location_name = file_name_to_original_location[relative_path]
-        if location_name == 'San Juan Mntns, Colorado':
-            # "part0/sub000/2010_Unit150_Ivan097_img0003.jpg"
-            tokens = relative_path.split('/')[-1].split('_')
-            assert tokens[1].startswith('Unit')
-            location_name = 'sanjuan_{}_{}_{}'.format(tokens[0],tokens[1],tokens[2])
-        elif location_name == 'Lebec, California':
-            # "part0/sub035/CA-03_08_13_2015_CA-03_0009738.jpg"
-            tokens = relative_path.split('/')[-1].split('_')
-            assert tokens[0].startswith('CA-') or tokens[0].startswith('TAG-')
-            location_name = 'lebec_{}'.format(tokens[0])   
-        elif location_name == 'Archbold, FL':
-            # "part1/sub110/FL-01_01_25_2016_FL-01_0040421.jpg"
-            tokens = relative_path.split('/')[-1].split('_')
-            assert tokens[0].startswith('FL-')
-            location_name = 'archbold_{}'.format(tokens[0])   
+    #%% Read metadata
+    
+    with open(input_file,'r') as f:
+        d = json.load(f)
+        
+    assert d['info']['version'] == 1.13
+    
+    
+    #%% Map images to locations (according to the metadata)
+    
+    file_name_to_original_location = {}
+    
+    # im = dataset_labels['images'][0]
+    for im in tqdm(d['images']):
+        file_name_to_original_location[im['file_name']] = im['location']
+    
+    original_locations = set(file_name_to_original_location.values())
+    
+    print('Found {} locations in the original metadata:'.format(len(original_locations)))
+    for loc in original_locations:
+        print('[{}]'.format(loc))
+    
+    
+    #%% Map images to new locations
+    
+    def path_to_location(relative_path):
+        
+        relative_path = relative_path.replace('\\','/')
+        if relative_path in file_name_to_original_location:
+            location_name = file_name_to_original_location[relative_path]
+            if location_name == 'San Juan Mntns, Colorado':
+                # "part0/sub000/2010_Unit150_Ivan097_img0003.jpg"
+                tokens = relative_path.split('/')[-1].split('_')
+                assert tokens[1].startswith('Unit')
+                location_name = 'sanjuan_{}_{}_{}'.format(tokens[0],tokens[1],tokens[2])
+            elif location_name == 'Lebec, California':
+                # "part0/sub035/CA-03_08_13_2015_CA-03_0009738.jpg"
+                tokens = relative_path.split('/')[-1].split('_')
+                assert tokens[0].startswith('CA-') or tokens[0].startswith('TAG-')
+                location_name = 'lebec_{}'.format(tokens[0])   
+            elif location_name == 'Archbold, FL':
+                # "part1/sub110/FL-01_01_25_2016_FL-01_0040421.jpg"
+                tokens = relative_path.split('/')[-1].split('_')
+                assert tokens[0].startswith('FL-')
+                location_name = 'archbold_{}'.format(tokens[0])   
+            else:
+                assert location_name == ''
+                tokens = relative_path.split('/')[-1].split('_')
+                if tokens[0].startswith('CA-') or tokens[0].startswith('TAG-') or tokens[0].startswith('FL-'):
+                    location_name = '{}'.format(tokens[0])
+                
         else:
-            assert location_name == ''
-            tokens = relative_path.split('/')[-1].split('_')
-            if tokens[0].startswith('CA-') or tokens[0].startswith('TAG-') or tokens[0].startswith('FL-'):
-                location_name = '{}'.format(tokens[0])
             
-    else:
+            location_name = 'unknown'    
         
-        location_name = 'unknown'    
+        # print('Returning location {} for file {}'.format(location_name,relative_path))          
     
-    # print('Returning location {} for file {}'.format(location_name,relative_path))          
-
-    return location_name
-
-file_name_to_updated_location = {}
-updated_location_to_count = defaultdict(int)
-for im in tqdm(d['images']):
+        return location_name
     
-    updated_location = path_to_location(im['file_name'])
-    file_name_to_updated_location[im['file_name']] = updated_location
-    updated_location_to_count[updated_location] += 1
-
-updated_location_to_count = {k: v for k, v in sorted(updated_location_to_count.items(), 
-                         key=lambda item: item[1],
-                         reverse=True)}
-
-updated_locations = set(file_name_to_updated_location.values())
-
-print('Found {} updated locations in the original metadata:'.format(len(updated_locations)))
-for loc in updated_location_to_count:
-    print('{}: {}'.format(loc,updated_location_to_count[loc]))
-
-
-#%% Re-write metadata
-
-for im in d['images']:
-    im['location'] = file_name_to_updated_location[im['file_name']]
-d['info']['version'] = 1.14
-
-with open(output_file,'w') as f:
-    json.dump(d,f,indent=1)
+    file_name_to_updated_location = {}
+    updated_location_to_count = defaultdict(int)
+    for im in tqdm(d['images']):
+        
+        updated_location = path_to_location(im['file_name'])
+        file_name_to_updated_location[im['file_name']] = updated_location
+        updated_location_to_count[updated_location] += 1
     
-
-#%% For each location, sample some random images to make sure they look consistent
-
-input_base = r'd:\lila\nacti-unzipped'
-assert os.path.isdir(input_base)
-
-location_to_images = defaultdict(list)
-
-for im in d['images']:
-    location_to_images[im['location']].append(im)
+    updated_location_to_count = {k: v for k, v in sorted(updated_location_to_count.items(), 
+                             key=lambda item: item[1],
+                             reverse=True)}
     
-n_to_sample = 10
-import random
-random.seed(0)
-sampling_folder_base = r'g:\temp\nacti_samples'
-
-for location in tqdm(location_to_images):
+    updated_locations = set(file_name_to_updated_location.values())
     
-    images_this_location = location_to_images[location]
-    if len(images_this_location) > n_to_sample:
-        images_this_location = random.sample(images_this_location,n_to_sample)
-        
-    for i_image,im in enumerate(images_this_location):
+    print('Found {} updated locations in the original metadata:'.format(len(updated_locations)))
+    for loc in updated_location_to_count:
+        print('{}: {}'.format(loc,updated_location_to_count[loc]))
+    
+    
+    #%% Re-write metadata
+    
+    for im in d['images']:
+        im['location'] = file_name_to_updated_location[im['file_name']]
+    d['info']['version'] = 1.14
+    
+    with open(output_file,'w') as f:
+        json.dump(d,f,indent=1)
         
-        fn_relative = im['file_name']
-        source_fn_abs = os.path.join(input_base,fn_relative)
-        assert os.path.isfile(source_fn_abs)
-        ext = os.path.splitext(fn_relative)[1]            
-        target_fn_abs = os.path.join(sampling_folder_base,'{}/{}'.format(
-            location,'image_{}{}'.format(str(i_image).zfill(2),ext)))
-        os.makedirs(os.path.dirname(target_fn_abs),exist_ok=True)
-        shutil.copyfile(source_fn_abs,target_fn_abs)
+    
+    #%% For each location, sample some random images to make sure they look consistent
+    
+    input_base = r'd:\lila\nacti-unzipped'
+    assert os.path.isdir(input_base)
+    
+    location_to_images = defaultdict(list)
+    
+    for im in d['images']:
+        location_to_images[im['location']].append(im)
         
-    # ...for each image
+    n_to_sample = 10
+    import random
+    random.seed(0)
+    sampling_folder_base = r'g:\temp\nacti_samples'
     
-# ...for each location
+    for location in tqdm(location_to_images):
+        
+        images_this_location = location_to_images[location]
+        if len(images_this_location) > n_to_sample:
+            images_this_location = random.sample(images_this_location,n_to_sample)
             
+        for i_image,im in enumerate(images_this_location):
+            
+            fn_relative = im['file_name']
+            source_fn_abs = os.path.join(input_base,fn_relative)
+            assert os.path.isfile(source_fn_abs)
+            ext = os.path.splitext(fn_relative)[1]            
+            target_fn_abs = os.path.join(sampling_folder_base,'{}/{}'.format(
+                location,'image_{}{}'.format(str(i_image).zfill(2),ext)))
+            os.makedirs(os.path.dirname(target_fn_abs),exist_ok=True)
+            shutil.copyfile(source_fn_abs,target_fn_abs)
+            
+        # ...for each image
+        
+    # ...for each location
+                

megadetector/data_management/lila/generate_lila_per_image_labels.py

@@ -349,7 +349,7 @@ with open(output_file,'w',encoding='utf-8',newline='') as f:
 
 # ...with open()
 
-print('Processed {} datasets'.format(len(metadata_table)))
+print('\nProcessed {} datasets'.format(len(metadata_table)))
 
 
 #%% Read the .csv back
@@ -393,7 +393,7 @@ def check_row(row):
     dataset_name_to_locations[ds_name].add(row['location_id'])
     
 # Faster, but more annoying to debug
-if False:
+if True:
     
     df.progress_apply(check_row, axis=1)