megadetector 5.0.5__py3-none-any.whl → 5.0.7__py3-none-any.whl

data_management/coco_to_yolo.py

@@ -37,10 +37,12 @@ def write_yolo_dataset_file(yolo_dataset_file,
                             val_folder_relative=None,
                             test_folder_relative=None):
     """
-    Write a YOLOv5 dataset.yaml file to the file yolo_dataset_file (should
+    Write a YOLOv5 dataset.yaml file to the absolute path yolo_dataset_file (should
     have a .yaml extension, though it's only a warning if it doesn't).  
 
     [dataset_base_dir] should be the absolute path of the dataset root.
+    
+    yolo_dataset_file does not have to be within dataset_base_dir.
 
     [class_list] can be 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 
@@ -87,10 +89,12 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
                  images_to_exclude=None,
                  path_replacement_char='#',
                  category_names_to_exclude=None,
-                 write_output=True):
+                 category_names_to_include=None,
+                 write_output=True,
+                 flatten_paths=True):
     """
-    Convert a COCO-formatted dataset to a YOLO-formatted dataset, flattening the dataset
-    (to a single folder) in the process.
+    Convert a COCO-formatted dataset to a YOLO-formatted dataset, optionally flattening the 
+    dataset to a single folder in the process.
     
     If the input and output folders are the same, writes .txt files to the input folder,
     and neither moves nor modifies images.
@@ -128,6 +132,9 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
         
     ## Validate input
     
+    if category_names_to_include is not None and category_names_to_exclude is not None:
+        raise ValueError('category_names_to_include and category_names_to_exclude are mutually exclusive')
+        
     if output_folder is None:
         output_folder = input_image_folder
     
@@ -136,12 +143,16 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
             
     if category_names_to_exclude is None:
         category_names_to_exclude = {}
-        
+            
     assert os.path.isdir(input_image_folder)
     assert os.path.isfile(input_file)
     os.makedirs(output_folder,exist_ok=True)
     
-    
+    if (output_folder == input_image_folder) and (overwrite_images) and \
+        (not create_image_and_label_folders) and (not flatten_paths):
+            print('Warning: output folder and input folder are the same, disabling overwrite_images')
+            overwrite_images = False
+            
     ## Read input data
     
     with open(input_file,'r') as f:
@@ -182,7 +193,11 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
     
     for category in data['categories']:
         coco_id_to_name[category['id']] = category['name']
-        if (category['name'] in category_names_to_exclude):
+        if (category_names_to_include is not None) and \
+            (category['name'] not in category_names_to_include):
+            coco_category_ids_to_exclude.add(category['id'])
+            continue
+        elif (category['name'] in category_names_to_exclude):
             coco_category_ids_to_exclude.add(category['id'])
             continue               
         assert category['id'] not in coco_id_to_yolo_id
@@ -226,9 +241,13 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
         tokens = os.path.splitext(im['file_name'])
         if tokens[1].lower() not in typical_image_extensions:
             print('Warning: unusual image file name {}'.format(im['file_name']))
-                  
-        image_name = tokens[0].replace('\\','/').replace('/',path_replacement_char) + \
-            '_' + str(i_image).zfill(6)
+                
+        if flatten_paths:
+            image_name = tokens[0].replace('\\','/').replace('/',path_replacement_char) + \
+                '_' + str(i_image).zfill(6)            
+        else:
+            image_name = tokens[0]
+
         assert image_name not in image_names, 'Image name collision for {}'.format(image_name)
         image_names.add(image_name)
         
@@ -291,12 +310,6 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
                 # This category isn't in our category list.  This typically corresponds to whole sets
                 # of images that were excluded from the YOLO set.
                 if ann['category_id'] in coco_category_ids_to_exclude:
-                    category_name = coco_id_to_name[ann['category_id']]
-                    if category_name not in category_exclusion_warnings_printed:
-                        category_exclusion_warnings_printed.add(category_name)
-                        print('Warning: ignoring category {} in image {}'.format(
-                            category_name,image_id),end='')
-                        print('...are you sure you didn\'t mean to exclude this image?')                        
                     continue
                 
                 yolo_category_id = coco_id_to_yolo_id[ann['category_id']]
@@ -405,30 +418,38 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
         with open(image_id_to_output_image_json_file,'w') as f:
             json.dump(image_id_to_output_image_name,f,indent=1)
     
-    if (write_output):
-    
+
+    if (output_folder == input_image_folder) and (not create_image_and_label_folders):
+        print('Creating annotation files (not copying images, input and output folder are the same)')
+    else:
         print('Copying images and creating annotation files')
+
+    if create_image_and_label_folders:
+        dest_image_folder = os.path.join(output_folder,'images')
+        dest_txt_folder = os.path.join(output_folder,'labels')
+    else:
+        dest_image_folder = output_folder
+        dest_txt_folder = output_folder
+        
+    source_image_to_dest_image = {}
     
-        if create_image_and_label_folders:
-            dest_image_folder = os.path.join(output_folder,'images')
-            dest_txt_folder = os.path.join(output_folder,'labels')
-        else:
-            dest_image_folder = output_folder
-            dest_txt_folder = output_folder
-            
-        # TODO: parallelize this loop
-        #
-        # output_info = images_to_copy[0]
-        for output_info in tqdm(images_to_copy):
-    
-            source_image = output_info['source_image']
-            dest_image_relative = output_info['dest_image_relative']
-            dest_txt_relative = output_info['dest_txt_relative']
-            
-            dest_image = os.path.join(dest_image_folder,dest_image_relative)
-            os.makedirs(os.path.dirname(dest_image),exist_ok=True)
+    # TODO: parallelize this loop
+    #
+    # output_info = images_to_copy[0]
+    for output_info in tqdm(images_to_copy):
+
+        source_image = output_info['source_image']
+        dest_image_relative = output_info['dest_image_relative']
+        dest_txt_relative = output_info['dest_txt_relative']
+        
+        dest_image = os.path.join(dest_image_folder,dest_image_relative)
+        dest_txt = os.path.join(dest_txt_folder,dest_txt_relative)
+        
+        source_image_to_dest_image[source_image] = dest_image
+        
+        if write_output:
             
-            dest_txt = os.path.join(dest_txt_folder,dest_txt_relative)
+            os.makedirs(os.path.dirname(dest_image),exist_ok=True)        
             os.makedirs(os.path.dirname(dest_txt),exist_ok=True)
             
             if not create_image_and_label_folders:
@@ -436,7 +457,7 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
             
             if (not os.path.isfile(dest_image)) or (overwrite_images):
                 shutil.copyfile(source_image,dest_image)
-            
+        
             bboxes = output_info['bboxes']        
             
             # Only write an annotation file if there are bounding boxes.  Images with 
@@ -456,15 +477,17 @@ def coco_to_yolo(input_image_folder,output_folder,input_file,
                         assert len(bbox) == 5
                         s = '{} {} {} {} {}'.format(bbox[0],bbox[1],bbox[2],bbox[3],bbox[4])
                         f.write(s + '\n')
-                
-        # ...for each image
+                        
+        # ...if we're actually writing output
         
-    # ...if we're actually writing output
-
-    return_info = {}
-    return_info['class_list_filename'] = class_list_filename
+    # ...for each image
+    
+    coco_to_yolo_info = {}
+    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
     
-    return return_info
+    return coco_to_yolo_info
 
 # ...def coco_to_yolo(...)
 

data_management/databases/integrity_check_json_db.py

@@ -89,6 +89,9 @@ def integrity_check_json_db(jsonFile, options=None):
         
     print(options.__dict__)
     
+    if options.baseDir is None:
+        options.baseDir = ''
+        
     baseDir = options.baseDir
     
     
@@ -116,10 +119,9 @@ def integrity_check_json_db(jsonFile, options=None):
     annotations = data['annotations']
     categories = data['categories']
     # info = data['info']
-    assert 'info' in data
+    assert 'info' in data, 'No info struct in database'
     
-    if len(baseDir) > 0:
-        
+    if len(baseDir) > 0:        
         assert os.path.isdir(baseDir), 'Base directory {} does not exist'.format(baseDir)
         
         
@@ -139,8 +141,8 @@ def integrity_check_json_db(jsonFile, options=None):
         assert 'name' in cat
         assert 'id' in cat
         
-        assert isinstance(cat['id'],int), 'Illegal category ID type'
-        assert isinstance(cat['name'],str), 'Illegal category name type'
+        assert isinstance(cat['id'],int), 'Illegal category ID type: [{}]'.format(str(cat['id']))
+        assert isinstance(cat['name'],str), 'Illegal category name type [{}]'.format(str(cat['name']))
         
         catId = cat['id']
         catName = cat['name']

data_management/generate_crops_from_cct.py

@@ -145,7 +145,7 @@ if False:
 
     #%%
     
-    from md_visualization.visualize_db import DbVizOptions,process_images
+    from md_visualization.visualize_db import DbVizOptions,visualize_db
     
     db_path = cct_file
     output_dir = os.path.expanduser('~/tmp/noaa-fish-preview')
@@ -163,5 +163,5 @@ if False:
     options.box_thickness = 4
     options.box_expansion = 25
     
-    htmlOutputFile,db = process_images(db_path,output_dir,image_base_dir,options)
-    
+    htmlOutputFile,db = visualize_db(db_path,output_dir,image_base_dir,options)
+    

data_management/get_image_sizes.py

@@ -2,7 +2,8 @@
 #
 # get_image_sizes.py
 #
-# Given a json-formatted list of image filenames, retrieve the width and height of every image.
+# Given a json-formatted list of image filenames, retrieve the width and height of 
+# every image, optionally writing the results to a new .json file.
 #
 ########
 
@@ -70,7 +71,7 @@ def process_images(filenames,image_prefix=None,n_threads=default_n_threads):
     return all_results
 
 
-def process_list_file(input_file,output_file,image_prefix=None,n_threads=default_n_threads):
+def process_list_file(input_file,output_file=None,image_prefix=None,n_threads=default_n_threads):
     
     assert os.path.isdir(os.path.dirname(output_file))
     assert os.path.isfile(input_file)
@@ -81,8 +82,9 @@ def process_list_file(input_file,output_file,image_prefix=None,n_threads=default
     
     all_results = process_images(filenames,image_prefix=image_prefix,n_threads=n_threads)
     
-    with open(output_file,'w') as f:
-        json.dump(all_results,f,indent=2)
+    if output_file is not None:
+        with open(output_file,'w') as f:
+            json.dump(all_results,f,indent=1)
     
     
 #%% Interactive driver
@@ -102,14 +104,14 @@ if False:
     image_names = path_utils.find_images(base_dir,recursive=True)
     
     with open(image_list_file,'w') as f:
-        json.dump(image_names,f,indent=2)
+        json.dump(image_names,f,indent=1)
         
     relative_image_names = []
     for s in image_names:
         relative_image_names.append(os.path.relpath(s,base_dir))
     
     with open(relative_image_list_file,'w') as f:
-        json.dump(relative_image_names,f,indent=2)
+        json.dump(relative_image_names,f,indent=1)
     
     
     #%%

data_management/importers/add_timestamps_to_icct.py

@@ -0,0 +1,79 @@
+########
+#
+# add_timestamps_to_icct.py
+#
+# The Island Conservation Camera Traps dataset was originally posted without timestamps
+# in either .json metadata or EXIF metadata.  We pulled timestamps out using ocr_tools.py,
+# this script adds those timestamps into the .json metadata.
+#
+########
+
+#%% Imports and constants
+
+import json
+
+ocr_results_file = r'g:\temp\ocr_results.2023.10.31.07.37.54.json'
+input_metadata_file = r'd:\lila\islandconservationcameratraps\island_conservation.json'
+output_metadata_file = r'g:\temp\island_conservation_camera_traps_1.02.json'
+ocr_results_file_base = 'g:/temp/island_conservation_camera_traps/'
+assert ocr_results_file_base.endswith('/')
+
+
+#%% Read input metadata
+
+with open(input_metadata_file,'r') as f:
+    input_metadata = json.load(f)
+    
+assert input_metadata['info']['version'] == '1.01'
+
+# im = input_metadata['images'][0]
+for im in input_metadata['images']:
+    assert 'datetime' not in im
+    
+
+#%% Read OCR results
+
+with open(ocr_results_file,'r') as f:
+    abs_filename_to_ocr_results = json.load(f)
+    
+relative_filename_to_ocr_results = {}
+
+for fn_abs in abs_filename_to_ocr_results:
+    assert ocr_results_file_base in fn_abs
+    fn_relative = fn_abs.replace(ocr_results_file_base,'')
+    relative_filename_to_ocr_results[fn_relative] = abs_filename_to_ocr_results[fn_abs]
+    
+
+#%% Add datetimes to metadata
+
+images_not_in_datetime_results = []
+images_with_failed_datetimes = []
+
+for i_image,im in enumerate(input_metadata['images']):
+    if im['file_name'] not in relative_filename_to_ocr_results:
+        images_not_in_datetime_results.append(im)
+        im['datetime'] = None
+        continue
+    ocr_results = relative_filename_to_ocr_results[im['file_name']]
+    if ocr_results['datetime'] is None:
+        images_with_failed_datetimes.append(im)
+        im['datetime'] = None
+        continue
+    im['datetime'] = ocr_results['datetime']
+
+print('{} of {} images were not in datetime results'.format(
+    len(images_not_in_datetime_results),len(input_metadata['images'])))
+
+print('{} of {} images were had failed datetime results'.format(
+    len(images_with_failed_datetimes),len(input_metadata['images'])))
+
+for im in input_metadata['images']:
+    assert 'datetime' in im
+
+
+#%% Write output
+
+input_metadata['info']['version'] = '1.02'
+
+with open(output_metadata_file,'w') as f:
+    json.dump(input_metadata,f,indent=1)

data_management/importers/animl_results_to_md_results.py

@@ -0,0 +1,160 @@
+########
+#
+# animl_results_to_md_results.py
+#
+# Convert a .csv file produced by the Animl package:
+#
+# https://github.com/conservationtechlab/animl-py
+#
+# ...to a MD results file suitable for import into Timelapse.
+#
+# Columns are expected to be:
+#
+# file
+# category (MD category identifies: 1==animal, 2==person, 3==vehicle)
+# detection_conf
+# bbox1,bbox2,bbox3,bbox4
+# class
+# classification_conf
+#
+########
+
+#%% Imports and constants
+
+import pandas as pd
+import json
+
+# It's a little icky to hard-code this here rather than importing from elsewhere
+# in the MD repo, but it seemed silly to take a dependency on lots of MD code
+# just for this, so, hard-coding.
+detection_category_id_to_name = {'1':'animal','2':'person','3':'vehicle'}
+
+
+#%% Main function
+
+def animl_results_to_md_results(input_file,output_file=None):
+    """
+    Converts the .csv file [input_file] to the MD-formatted .json file [output_file].
+    
+    If [output_file] is None, '.json' will be appended to the input file.
+    """
+    
+    #%%
+    
+    if output_file is None:
+        output_file = input_file + '.json'
+
+    df = pd.read_csv(input_file)
+    
+    expected_columns = ('file','category','detection_conf',
+                        'bbox1','bbox2','bbox3','bbox4','class','classification_conf')
+    
+    for s in expected_columns:
+        assert s in df.columns,\
+            'Expected column {} not found'.format(s)
+            
+    classification_category_name_to_id = {}    
+    filename_to_results = {}
+    
+    # i_row = 0; row = df.iloc[i_row]
+    for i_row,row in df.iterrows():
+            
+        # Is this the first detection we've seen for this file?            
+        if row['file'] in filename_to_results:
+            im = filename_to_results[row['file']]
+        else:
+            im = {}
+            im['detections'] = []
+            im['file'] = row['file']
+            filename_to_results[im['file']] = im
+            
+        assert isinstance(row['category'],int),'Invalid category identifier in row {}'.format(im['file'])
+        detection_category_id = str(row['category'])
+        assert detection_category_id in detection_category_id_to_name,\
+            'Unrecognized detection category ID {}'.format(detection_category_id)
+            
+        detection = {}
+        detection['category'] = detection_category_id
+        detection['conf'] = row['detection_conf']
+        bbox = [row['bbox1'],row['bbox2'],row['bbox3'],row['bbox4']]
+        detection['bbox'] = bbox
+        classification_category_name = row['class']
+        
+        # Have we seen this classification category before?
+        if classification_category_name in classification_category_name_to_id:
+            classification_category_id = \
+                classification_category_name_to_id[classification_category_name]
+        else:
+            classification_category_id = str(len(classification_category_name_to_id))
+            classification_category_name_to_id[classification_category_name] = \
+                classification_category_id
+        
+        classifications = [[classification_category_id,row['classification_conf']]]
+        detection['classifications'] = classifications
+        
+        im['detections'].append(detection)
+        
+    # ...for each row        
+        
+    info = {}
+    info['format_version'] = '1.3'
+    info['detector'] = 'Animl'
+    info['classifier'] = 'Animl'
+    
+    results = {}
+    results['info'] = info
+    results['detection_categories'] = detection_category_id_to_name
+    results['classification_categories'] = \
+        {v: k for k, v in classification_category_name_to_id.items()}
+    results['images'] = list(filename_to_results.values())
+    
+    with open(output_file,'w') as f:
+        json.dump(results,f,indent=1)
+        
+# ...zamba_results_to_md_results(...)
+        
+
+#%% Interactive driver
+
+if False:
+
+    pass
+
+    #%%
+    
+    input_file = r"G:\temp\animl-runs\animl-runs\Coati_v2\manifest.csv"
+    output_file = None
+    animl_results_to_md_results(input_file,output_file)
+    
+
+#%% Command-line driver
+
+import sys,argparse
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        description='Convert an Animl-formatted .csv results file to MD-formatted .json results file')
+    
+    parser.add_argument(
+        'input_file',
+        type=str,
+        help='input .csv file')
+    
+    parser.add_argument(
+        '--output_file',
+        type=str,
+        default=None,
+        help='output .json file (defaults to input file appended with ".json")')
+    
+    if len(sys.argv[1:]) == 0:
+        parser.print_help()
+        parser.exit()
+
+    args = parser.parse_args()
+
+    animl_results_to_md_results(args.input_file,args.output_file)
+    
+if __name__ == '__main__':
+    main()
+    

data_management/importers/auckland_doc_test_to_json.py

@@ -21,7 +21,7 @@ import numpy as np
 from tqdm import tqdm
 
 from md_visualization import visualize_db
-from data_management.databases import sanity_check_json_db
+from data_management.databases import integrity_check_json_db
 from md_utils.path_utils import find_images
 
 input_base_dir = r'e:\auckland-test\2_Testing'
@@ -314,13 +314,13 @@ print('Finished writing json to {}'.format(output_json_filename))
 
 #%% Validate .json file
 
-options = sanity_check_json_db.SanityCheckOptions()
+options = integrity_check_json_db.IntegrityCheckOptions()
 options.baseDir = input_base_dir
 options.bCheckImageSizes = False
 options.bCheckImageExistence = False
 options.bFindUnusedImages = False
 
-sortedCategories, data, _ = sanity_check_json_db.sanity_check_json_db(output_json_filename, options)
+sortedCategories, data, _ = integrity_check_json_db.integrity_check_json_db(output_json_filename, options)
 
 
 #%% Preview labels
@@ -332,7 +332,7 @@ viz_options.add_search_links = False
 viz_options.sort_by_filename = False
 viz_options.parallelize_rendering = True
 viz_options.classes_to_exclude = ['empty']
-html_output_file, image_db = visualize_db.process_images(db_path=output_json_filename,
+html_output_file, image_db = visualize_db.visualize_db(db_path=output_json_filename,
                                                          output_dir=os.path.join(
                                                          output_base_dir, 'preview'),
                                                          image_base_dir=input_base_dir,

data_management/importers/auckland_doc_to_json.py

@@ -192,7 +192,7 @@ 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.process_images(db_path=output_json_filename,
+html_output_file, image_db = visualize_db.visualize_db(db_path=output_json_filename,
                                                          output_dir=os.path.join(
                                                          output_base_dir, 'preview'),
                                                          image_base_dir=input_base_dir,

data_management/importers/awc_to_json.py

@@ -168,12 +168,12 @@ print('Finished writing .json file with {} images, {} annotations, and {} catego
         len(images),len(annotations),len(categories)))
 
 
-#%% Sanity-check the database's integrity
+#%% Validate the database's integrity
 
-from data_management.databases import sanity_check_json_db
+from data_management.databases import integrity_check_json_db
 
-options = sanity_check_json_db.SanityCheckOptions()
-sortedCategories,data = sanity_check_json_db.sanity_check_json_db(output_file, options)
+options = integrity_check_json_db.IntegrityCheckOptions()
+sortedCategories,data = integrity_check_json_db.integrity_check_json_db(output_file, options)
 
     
 #%% Render a bunch of images to make sure the labels got carried along correctly
@@ -185,5 +185,5 @@ options = visualize_db.BboxDbVizOptions()
 options.num_to_visualize = 1000
 options.sort_by_filename = False
 
-htmlOutputFile = visualize_db.process_images(bbox_db_path,output_dir,image_base,options)
+htmlOutputFile = visualize_db.visualize_db(bbox_db_path,output_dir,image_base,options)
 

data_management/importers/bellevue_to_json.py

@@ -242,17 +242,17 @@ json.dump(data, open(output_filename,'w'), indent=1)
 print('Finished writing json to {}'.format(output_filename))
 
 
-#%% Sanity-check data
+#%% Validate data
 
-from data_management.databases import sanity_check_json_db
+from data_management.databases import integrity_check_json_db
 
-options = sanity_check_json_db.SanityCheckOptions()
+options = integrity_check_json_db.IntegrityCheckOptions()
 options.baseDir = base_dir
 options.bCheckImageSizes = False
 options.bCheckImageExistence = True
 options.bFindUnusedImages = False
     
-sorted_categories  = sanity_check_json_db.sanity_check_json_db(output_filename,options)
+sorted_categories  = integrity_check_json_db.integrity_check_json_db(output_filename,options)
 
 
 #%% Label previews
@@ -266,7 +266,7 @@ viz_options.parallelize_rendering = True
 viz_options.trim_to_images_with_bboxes = False
 viz_options.add_search_links = True
 viz_options.sort_by_filename = False
-html_output_file,image_db = visualize_db.process_images(output_filename,
+html_output_file,image_db = visualize_db.visualize_db(output_filename,
                                                         os.path.join(output_base,'preview'),
                                                         base_dir,viz_options)
 os.startfile(html_output_file)

data_management/importers/carrizo_shrubfree_2018.py

@@ -237,20 +237,20 @@ print('Finished writing .json file with {} images, {} annotations, and {} catego
 
 #%% Validate output
 
-from data_management.databases import sanity_check_json_db
+from data_management.databases import integrity_check_json_db
 
-options = sanity_check_json_db.SanityCheckOptions()
+options = integrity_check_json_db.IntegrityCheckOptions()
 options.baseDir = image_directory
 options.bCheckImageSizes = False
 options.bCheckImageExistence = False
 options.bFindUnusedImages = False
-data = sanity_check_json_db.sanity_check_json_db(output_json_file,options)
+data = integrity_check_json_db.integrity_check_json_db(output_json_file,options)
 
 
 #%% Preview labels
 
 from md_visualization import visualize_db
-from data_management.databases import sanity_check_json_db
+from data_management.databases import integrity_check_json_db
 
 viz_options = visualize_db.DbVizOptions()
 viz_options.num_to_visualize = None
@@ -259,7 +259,7 @@ viz_options.add_search_links = True
 viz_options.sort_by_filename = False
 viz_options.parallelize_rendering = True
 viz_options.classes_to_exclude = ['empty']
-html_output_file,image_db = visualize_db.process_images(db_path=output_json_file,
+html_output_file,image_db = visualize_db.visualize_db(db_path=output_json_file,
                                                         output_dir=os.path.join(
                                                         output_base, 'carrizo shrub-free 2018/preview'),
                                                         image_base_dir=image_directory,