megadetector 10.0.10__py3-none-any.whl → 10.0.11__py3-none-any.whl

megadetector/utils/path_utils.py

@@ -152,7 +152,6 @@ def folder_list(base_dir,
     folders = []
 
     if recursive:
-        folders = []
         for root, dirs, _ in os.walk(base_dir):
             for d in dirs:
                 folders.append(os.path.join(root, d))
@@ -370,7 +369,9 @@ def safe_create_link(link_exists,link_new):
             os.remove(link_new)
             os.symlink(link_exists,link_new)
     else:
-        os.makedirs(os.path.dirname(link_new),exist_ok=True)
+        link_new_dir = os.path.dirname(link_new)
+        if len(link_new_dir) > 0:
+            os.makedirs(link_new_dir,exist_ok=True)
         os.symlink(link_exists,link_new)
 
  # ...def safe_create_link(...)
@@ -988,7 +989,9 @@ def _copy_file(input_output_tuple,overwrite=True,verbose=False,move=False):
     if verbose:
         print('{} to {}'.format(action_string,target_fn))
 
-    os.makedirs(os.path.dirname(target_fn),exist_ok=True)
+    target_dir = os.path.dirname(target_fn)
+    if len(target_dir) > 0:
+        os.makedirs(target_dir,exist_ok=True)
     if move:
         shutil.move(source_fn, target_fn)
     else:
@@ -1038,10 +1041,11 @@ def parallel_copy_files(input_file_to_output_file,
                                                     input_output_tuples)):
                 pbar.update()
     finally:
-        pool.close()
-        pool.join()
-        if verbose:
-            print("Pool closed and joined parallel file copying")
+        if pool is not None:
+            pool.close()
+            pool.join()
+            if verbose:
+                print("Pool closed and joined parallel file copying")
 
 # ...def parallel_copy_files(...)
 
@@ -1100,15 +1104,24 @@ def parallel_delete_files(input_files,
 
     n_workers = min(max_workers, len(input_files))
 
-    if use_threads:
-        pool = ThreadPool(n_workers)
-    else:
-        pool = Pool(n_workers)
+    pool = None
 
-    with tqdm(total=len(input_files)) as pbar:
-        for i, _ in enumerate(pool.imap_unordered(partial(delete_file, verbose=verbose),
-                                                  input_files)):
-            pbar.update()
+    try:
+        if use_threads:
+            pool = ThreadPool(n_workers)
+        else:
+            pool = Pool(n_workers)
+
+        with tqdm(total=len(input_files)) as pbar:
+            for i, _ in enumerate(pool.imap_unordered(partial(delete_file, verbose=verbose),
+                                                    input_files)):
+                pbar.update()
+    finally:
+        if pool is not None:
+            pool.close()
+            pool.join()
+            if verbose:
+                print('Pool closed and joined for file deletion')
 
 # ...def parallel_delete_files(...)
 
@@ -1185,8 +1198,6 @@ def parallel_get_file_sizes(filenames,
         dict: dictionary mapping filenames to file sizes in bytes
     """
 
-    n_workers = min(max_workers,len(filenames))
-
     folder_name = None
 
     if isinstance(filenames,str):
@@ -1204,23 +1215,37 @@ def parallel_get_file_sizes(filenames,
 
         assert is_iterable(filenames), '[filenames] argument is neither a folder nor an iterable'
 
+    n_workers = min(max_workers,len(filenames))
+
     if verbose:
         print('Creating worker pool')
 
-    if use_threads:
-        pool_string = 'thread'
-        pool = ThreadPool(n_workers)
-    else:
-        pool_string = 'process'
-        pool = Pool(n_workers)
+    pool = None
 
-    if verbose:
-        print('Created a {} pool of {} workers'.format(
-            pool_string,n_workers))
+    try:
 
-    # This returns (filename,size) tuples
-    get_size_results = list(tqdm(pool.imap(
-        partial(_get_file_size,verbose=verbose),filenames), total=len(filenames)))
+        if use_threads:
+            pool_string = 'thread'
+            pool = ThreadPool(n_workers)
+        else:
+            pool_string = 'process'
+            pool = Pool(n_workers)
+
+        if verbose:
+            print('Created a {} pool of {} workers'.format(
+                pool_string,n_workers))
+
+        # This returns (filename,size) tuples
+        get_size_results = list(tqdm(pool.imap(
+            partial(_get_file_size,verbose=verbose),filenames), total=len(filenames)))
+
+    finally:
+
+        if pool is not None:
+            pool.close()
+            pool.join()
+            if verbose:
+                print('Pool closed and join for file size collection')
 
     to_return = {}
     for r in get_size_results:
@@ -1275,6 +1300,8 @@ def zip_file(input_fn, output_fn=None, overwrite=False, verbose=False, compress_
 
     return output_fn
 
+# ...def zip_file(...)
+
 
 def add_files_to_single_tar_file(input_files, output_fn, arc_name_base,
                                  overwrite=False, verbose=False, mode='x'):
@@ -1315,6 +1342,8 @@ def add_files_to_single_tar_file(input_files, output_fn, arc_name_base,
 
     return output_fn
 
+# ...def add_files_to_single_tar_file(...)
+
 
 def zip_files_into_single_zipfile(input_files,
                                   output_fn,
@@ -1359,6 +1388,8 @@ def zip_files_into_single_zipfile(input_files,
 
     return output_fn
 
+# ...def zip_files_into_single_zipfile(...)
+
 
 def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, compress_level=9):
     """
@@ -1382,7 +1413,7 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
     if not overwrite:
         if os.path.isfile(output_fn):
             print('Zip file {} exists, skipping'.format(output_fn))
-            return
+            return output_fn
 
     if verbose:
         print('Zipping {} to {} (compression level {})'.format(
@@ -1400,6 +1431,8 @@ def zip_folder(input_folder, output_fn=None, overwrite=False, verbose=False, com
 
     return output_fn
 
+# ...def zip_folder(...)
+
 
 def parallel_zip_files(input_files,
                        max_workers=16,
@@ -1428,11 +1461,22 @@ def parallel_zip_files(input_files,
     else:
         pool = Pool(n_workers)
 
-    with tqdm(total=len(input_files)) as pbar:
-        for i,_ in enumerate(pool.imap_unordered(partial(zip_file,
-          output_fn=None,overwrite=overwrite,verbose=verbose,compress_level=compress_level),
-          input_files)):
-            pbar.update()
+    try:
+
+        with tqdm(total=len(input_files)) as pbar:
+            for i,_ in enumerate(pool.imap_unordered(partial(zip_file,
+            output_fn=None,overwrite=overwrite,verbose=verbose,compress_level=compress_level),
+            input_files)):
+                pbar.update()
+
+    finally:
+
+        pool.close()
+        pool.join()
+        if verbose:
+            print('Pool closed and joined for parallel zipping')
+
+# ...def parallel_zip_files(...)
 
 
 def parallel_zip_folders(input_folders,
@@ -1462,12 +1506,23 @@ def parallel_zip_folders(input_folders,
     else:
         pool = Pool(n_workers)
 
-    with tqdm(total=len(input_folders)) as pbar:
-        for i,_ in enumerate(pool.imap_unordered(
-                partial(zip_folder,overwrite=overwrite,
-                        compress_level=compress_level,verbose=verbose),
-                input_folders)):
-            pbar.update()
+    try:
+
+        with tqdm(total=len(input_folders)) as pbar:
+            for i,_ in enumerate(pool.imap_unordered(
+                    partial(zip_folder,overwrite=overwrite,
+                            compress_level=compress_level,verbose=verbose),
+                    input_folders)):
+                pbar.update()
+
+    finally:
+
+        pool.close()
+        pool.join()
+        if verbose:
+            print('Pool closed and joined for parallel folder zipping')
+
+# ...def parallel_zip_folders(...)
 
 
 def zip_each_file_in_folder(folder_name,
@@ -1510,6 +1565,8 @@ def zip_each_file_in_folder(folder_name,
                        use_threads=use_threads,compress_level=compress_level,
                        overwrite=overwrite,verbose=verbose)
 
+# ...def zip_each_file_in_folder(...)
+
 
 def unzip_file(input_file, output_folder=None):
     """
@@ -1617,9 +1674,20 @@ def parallel_compute_file_hashes(filenames,
         else:
             pool = Pool(n_workers)
 
-        results = list(tqdm(pool.imap(
-            partial(compute_file_hash,algorithm=algorithm,allow_failures=True),
-            filenames), total=len(filenames)))
+        try:
+
+            results = list(tqdm(pool.imap(
+                partial(compute_file_hash,algorithm=algorithm,allow_failures=True),
+                filenames), total=len(filenames)))
+
+        finally:
+
+            pool.close()
+            pool.join()
+            if verbose:
+                print('Pool closed and joined for parallel zipping')
+
+    # ...if we are/aren't parallelizing
 
     assert len(filenames) == len(results), 'Internal error in parallel_compute_file_hashes'
 

megadetector/utils/split_locations_into_train_val.py

@@ -221,14 +221,10 @@ def split_locations_into_train_val(location_to_category_counts,
     weighted_average_error,weighted_category_errors,category_to_val_fraction = \
         compute_seed_errors(min_error_seed)
 
-    random_seed = min_error_seed
-
-    category_to_val_fraction = sort_dictionary_by_value(category_to_val_fraction,reverse=True)
     category_to_val_fraction = sort_dictionary_by_value(category_to_val_fraction,
                                                         sort_values=category_id_to_count,
                                                         reverse=True)
 
-
     print('Val fractions by category:\n')
 
     for category in category_to_val_fraction:

megadetector/utils/url_utils.py

@@ -132,7 +132,8 @@ def download_url(url,
         if verbose:
             print('Downloading file {} to {}'.format(os.path.basename(url_no_sas),destination_filename),end='')
         target_dir = os.path.dirname(destination_filename)
-        os.makedirs(target_dir,exist_ok=True)
+        if len(target_dir) > 0:
+            os.makedirs(target_dir,exist_ok=True)
         urllib.request.urlretrieve(url, destination_filename, progress_updater)
         assert(os.path.isfile(destination_filename))
         n_bytes = os.path.getsize(destination_filename)
@@ -800,8 +801,9 @@ class TestUrlUtils:
 def _test_url_utils():
     """
     Runs all tests in the TestUrlUtils class.  I generally disable this during testing
-    because it creates irritating nondeterminism, and this is neither a core module nor
-    a module that changes often.
+    because it creates irritating nondeterminism (because it depends on downloading
+    stuff from the Internet), and this is neither a core module nor a module that changes
+    often.
     """
 
     test_instance = TestUrlUtils()

megadetector/utils/wi_taxonomy_utils.py

@@ -311,7 +311,8 @@ def taxonomy_info_to_taxonomy_string(taxonomy_info, include_taxon_id_and_common_
 def generate_whole_image_detections_for_classifications(classifications_json_file,
                                                         detections_json_file,
                                                         ensemble_json_file=None,
-                                                        ignore_blank_classifications=True):
+                                                        ignore_blank_classifications=True,
+                                                        verbose=True):
     """
     Given a set of classification results in SpeciesNet format that were likely run on
     already-cropped images, generate a file of [fake] detections in SpeciesNet format in which each
@@ -324,6 +325,7 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
             and classfications
         ignore_blank_classifications (bool, optional): use non-top classifications when
             the top classification is "blank" or "no CV result"
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         dict: the contents of [detections_json_file]
@@ -336,16 +338,37 @@ def generate_whole_image_detections_for_classifications(classifications_json_fil
     output_predictions = []
     ensemble_predictions = []
 
-    # prediction = predictions[0]
-    for prediction in predictions:
+    # i_prediction = 0; prediction = predictions[i_prediction]
+    for i_prediction,prediction in enumerate(predictions):
 
         output_prediction = {}
         output_prediction['filepath'] = prediction['filepath']
         i_score = 0
+
         if ignore_blank_classifications:
+
             while (prediction['classifications']['classes'][i_score] in \
                    (blank_prediction_string,no_cv_result_prediction_string)):
+
                 i_score += 1
+                if (i_score >= len(prediction['classifications']['classes'])):
+
+                    if verbose:
+
+                        print('Ignoring blank classifications, but ' + \
+                              'image {} has no non-blank values'.format(
+                                i_prediction))
+
+                    # Just use the first one
+                    i_score = 0
+                    break
+
+                # ...if we passed the last prediction
+
+            # ...iterate over classes within this prediction
+
+        # ...if we're supposed to ignore blank classifications
+
         top_classification = prediction['classifications']['classes'][i_score]
         top_classification_score = prediction['classifications']['scores'][i_score]
         if is_animal_classification(top_classification):
@@ -450,8 +473,8 @@ def generate_md_results_from_predictions_json(predictions_json_file,
 
     # Round floating-point values (confidence scores, coordinates) to a
     # reasonable number of decimal places
-    if max_decimals is not None and max_decimals > 0:
-        round_floats_in_nested_dict(predictions)
+    if (max_decimals is not None) and (max_decimals > 0):
+        round_floats_in_nested_dict(predictions, decimal_places=max_decimals)
 
     predictions = predictions['predictions']
     assert isinstance(predictions,list)
@@ -714,7 +737,9 @@ def generate_predictions_json_from_md_results(md_results_file,
 
     # ...for each image
 
-    os.makedirs(os.path.dirname(predictions_json_file),exist_ok=True)
+    output_dir = os.path.dirname(predictions_json_file)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir,exist_ok=True)
     with open(predictions_json_file,'w') as f:
         json.dump(output_dict,f,indent=1)
 
@@ -788,7 +813,9 @@ def generate_instances_json_from_folder(folder,
     to_return = {'instances':instances}
 
     if output_file is not None:
-        os.makedirs(os.path.dirname(output_file),exist_ok=True)
+        output_dir = os.path.dirname(output_file)
+        if len(output_dir) > 0:
+            os.makedirs(output_dir,exist_ok=True)
         with open(output_file,'w') as f:
             json.dump(to_return,f,indent=1)
 
@@ -870,7 +897,9 @@ def merge_prediction_json_files(input_prediction_files,output_prediction_file):
 
     output_dict = {'predictions':predictions}
 
-    os.makedirs(os.path.dirname(output_prediction_file),exist_ok=True)
+    output_dir = os.path.dirname(output_prediction_file)
+    if len(output_dir) > 0:
+        os.makedirs(output_dir,exist_ok=True)
     with open(output_prediction_file,'w') as f:
         json.dump(output_dict,f,indent=1)
 

megadetector/utils/write_html_image_list.py

@@ -110,7 +110,6 @@ def write_html_image_list(filename=None,images=None,options=None):
         if 'linkTarget' not in image_info:
             image_info['linkTarget'] = ''
         if 'textStyle' not in image_info:
-            text_style = options['defaultTextStyle']
             image_info['textStyle'] = options['defaultTextStyle']
         images[i_image] = image_info
 
@@ -185,7 +184,7 @@ def write_html_image_list(filename=None,images=None,options=None):
     if len(options['pageTitle']) > 0:
         title_string = '<title>{}</title>'.format(options['pageTitle'])
 
-    f_html.write('<html>{}<body>\n'.format(title_string))
+    f_html.write('<html><head>{}</head><body>\n'.format(title_string))
 
     f_html.write(options['headerHtml'])
 

megadetector/visualization/plot_utils.py

@@ -126,19 +126,16 @@ def plot_precision_recall_curve(precisions,
     ax.step(recalls, precisions, color='b', alpha=0.2, where='post')
     ax.fill_between(recalls, precisions, alpha=0.2, color='b', step='post')
 
-    try:
-        ax.set(x_label='Recall', y_label='Precision', title=title)
-        ax.set(x_lim=xlim, y_lim=ylim)
-    #
-    except Exception:
-        ax.set_xlabel('Recall')
-        ax.set_ylabel('Precision')
-        ax.set_title(title)
-        ax.set_xlim(xlim[0],xlim[1])
-        ax.set_ylim(ylim[0],ylim[1])
+    ax.set_xlabel('Recall')
+    ax.set_ylabel('Precision')
+    ax.set_title(title)
+    ax.set_xlim(xlim[0],xlim[1])
+    ax.set_ylim(ylim[0],ylim[1])
 
     return fig
 
+# ...def plot_precision_recall_curve(...)
+
 
 def plot_stacked_bar_chart(data,
                            series_labels=None,
@@ -174,17 +171,21 @@ def plot_stacked_bar_chart(data,
 
     # stacked bar charts are made with each segment starting from a y position
     cumulative_size = np.zeros(num_columns)
-    for i, row_data in enumerate(data):
-        ax.bar(ind, row_data, bottom=cumulative_size, label=series_labels[i],
-               color=colors[i])
+    for i_row, row_data in enumerate(data):
+        if series_labels is None:
+            label = 'series_{}'.format(str(i_row).zfill(2))
+        else:
+            label = series_labels[i_row]
+        ax.bar(ind, row_data, bottom=cumulative_size, label=label,
+               color=colors[i_row])
         cumulative_size += row_data
 
-    if col_labels and len(col_labels) < 25:
+    if (col_labels is not None) and (len(col_labels) < 25):
         ax.set_xticks(ind)
         ax.set_xticklabels(col_labels, rotation=90)
-    elif col_labels:
+    elif (col_labels is not None):
         ax.set_xticks(list(range(0, len(col_labels), 20)))
-        ax.set_xticklabels(col_labels, rotation=90)
+        ax.set_xticklabels(col_labels[::20], rotation=90)
 
     if x_label is not None:
         ax.set_xlabel(x_label)
@@ -202,6 +203,8 @@ def plot_stacked_bar_chart(data,
 
     return fig
 
+# ...def plot_stacked_bar_chart(...)
+
 
 def calibration_ece(true_scores, pred_scores, num_bins):
     r"""
@@ -245,10 +248,17 @@ def calibration_ece(true_scores, pred_scores, num_bins):
     ece = np.abs(accs - confs) @ weights
     return accs, confs, ece
 
+# ...def calibration_ece(...)
+
 
-def plot_calibration_curve(true_scores, pred_scores, num_bins,
-                           name='calibration', plot_perf=True, plot_hist=True,
-                           ax=None, **fig_kwargs):
+def plot_calibration_curve(true_scores,
+                           pred_scores,
+                           num_bins,
+                           name='calibration',
+                           plot_perf=True,
+                           plot_hist=True,
+                           ax=None,
+                           **fig_kwargs):
     """
     Plots a calibration curve.
 
@@ -295,3 +305,5 @@ def plot_calibration_curve(true_scores, pred_scores, num_bins,
         fig.legend(loc='upper left', bbox_to_anchor=(0.15, 0.85))
 
     return ax.figure
+
+# ...def plot_calibration_curve(...)

megadetector/visualization/render_images_with_thumbnails.py

@@ -185,6 +185,9 @@ def render_images_with_thumbnails(
     # ...for each crop
 
     # Write output image to disk
+    parent_dir = os.path.dirname(output_image_filename)
+    if len(parent_dir) > 0:
+        os.makedirs(parent_dir,exist_ok=True)
     output_image.save(output_image_filename)
 
 # ...def render_images_with_thumbnails(...)

megadetector/visualization/visualization_utils.py

@@ -1272,7 +1272,7 @@ def gray_scale_fraction(image,crop_size=(0.1,0.1)):
     if crop_size[0] > 0 or crop_size[1] > 0:
 
         assert (crop_size[0] + crop_size[1]) < 1.0, \
-            print('Illegal crop size: {}'.format(str(crop_size)))
+            'Illegal crop size: {}'.format(str(crop_size))
 
         top_crop_pixels = int(image.height * crop_size[0])
         bottom_crop_pixels = int(image.height * crop_size[1])
@@ -1391,7 +1391,9 @@ def _resize_absolute_image(input_output_files,
         status = 'error'
         error = str(e)
 
-    return {'input_fn':input_fn_abs,'output_fn':output_fn_abs,status:'status',
+    return {'input_fn':input_fn_abs,
+            'output_fn':output_fn_abs,
+            'status':status,
             'error':error}
 
 # ..._resize_absolute_image(...)
@@ -1460,6 +1462,7 @@ def resize_images(input_file_to_output_file,
         pool = None
 
         try:
+
             if pool_type == 'thread':
                 pool = ThreadPool(n_workers); poolstring = 'threads'
             else:
@@ -1477,10 +1480,13 @@ def resize_images(input_file_to_output_file,
                     quality=quality)
 
             results = list(tqdm(pool.imap(p, input_output_file_pairs),total=len(input_output_file_pairs)))
+
         finally:
-            pool.close()
-            pool.join()
-            print("Pool closed and joined for image resizing")
+
+            if pool is not None:
+                pool.close()
+                pool.join()
+                print('Pool closed and joined for image resizing')
 
     return results
 
@@ -1680,8 +1686,13 @@ def parallel_get_image_sizes(filenames,
         else:
             pool = Pool(n_workers)
 
-        results = list(tqdm(pool.imap(
-            partial(get_image_size,verbose=verbose),filenames), total=len(filenames)))
+        try:
+            results = list(tqdm(pool.imap(
+                partial(get_image_size,verbose=verbose),filenames), total=len(filenames)))
+        finally:
+            pool.close()
+            pool.join()
+            print('Pool closed and joined for image size retrieval')
 
     assert len(filenames) == len(results), 'Internal error in parallel_get_image_sizes'
 

megadetector/visualization/visualize_db.py

@@ -102,10 +102,6 @@ class DbVizOptions:
         #: :meta private:
         self.multiple_categories_tag = '*multiple*'
 
-        #: We sometimes flatten image directories by replacing a path separator with
-        #: another character.  Leave blank for the typical case where this isn't necessary.
-        self.pathsep_replacement = '' # '~'
-
         #: Parallelize rendering across multiple workers
         self.parallelize_rendering = False
 
@@ -141,24 +137,12 @@ class DbVizOptions:
         self.confidence_threshold = None
 
 
-#%% Helper functions
-
-def _image_filename_to_path(image_file_name, image_base_dir, pathsep_replacement=''):
-    """
-    Translates the file name in an image entry in the json database to a path, possibly doing
-    some manipulation of path separators.
-    """
-
-    if len(pathsep_replacement) > 0:
-        image_file_name = os.path.normpath(image_file_name).replace(os.pathsep,pathsep_replacement)
-    return os.path.join(image_base_dir, image_file_name)
-
-
 #%% Core functions
 
 def visualize_db(db_path, output_dir, image_base_dir, options=None):
     """
-    Writes images and html to output_dir to visualize the annotations in a .json file.
+    Writes images and html to output_dir to visualize the images and annotations in a
+    COCO-formatted .json file.
 
     Args:
         db_path (str or dict): the .json filename to load, or a previously-loaded database
@@ -176,9 +160,11 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
 
     # Consistency checking for fields with specific format requirements
 
-    # This should be a list, but if someone specifies a string, do a reasonable thing
+    # These should be a lists, but if someone specifies a string, do a reasonable thing
     if isinstance(options.extra_image_fields_to_print,str):
         options.extra_image_fields_to_print = [options.extra_image_fields_to_print]
+    if isinstance(options.extra_annotation_fields_to_print,str):
+        options.extra_annotation_fields_to_print = [options.extra_annotation_fields_to_print]
 
     if not options.parallelize_rendering_with_threads:
         print('Warning: process-based parallelization is not yet supported by visualize_db')
@@ -196,7 +182,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         assert(os.path.isfile(db_path))
         print('Loading database from {}...'.format(db_path))
         image_db = json.load(open(db_path))
-        print('...done')
+        print('...done, loaded {} images'.format(len(image_db['images'])))
     elif isinstance(db_path,dict):
         print('Using previously-loaded DB')
         image_db = db_path
@@ -312,8 +298,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         if image_base_dir.startswith('http'):
             img_path = image_base_dir + img_relative_path
         else:
-            img_path = os.path.join(image_base_dir,
-                                    _image_filename_to_path(img_relative_path, image_base_dir))
+            img_path = os.path.join(image_base_dir,img_relative_path).replace('\\','/')
 
         annos_i = df_anno.loc[df_anno['image_id'] == img_id, :] # all annotations on this image
 
@@ -407,7 +392,8 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         img_id_string = str(img_id).lower()
         file_name = '{}_gt.jpg'.format(os.path.splitext(img_id_string)[0])
 
-        # Replace characters that muck up image links
+        # Replace characters that muck up image links, including flattening file
+        # separators.
         illegal_characters = ['/','\\',':','\t','#',' ','%']
         for c in illegal_characters:
             file_name = file_name.replace(c,'~')
@@ -625,9 +611,6 @@ def main():
                         help='Only include images with bounding boxes (defaults to false)')
     parser.add_argument('--random_seed', action='store', type=int, default=None,
                         help='Random seed for image selection')
-    parser.add_argument('--pathsep_replacement', action='store', type=str, default='',
-                        help='Replace path separators in relative filenames with another ' + \
-                             'character (frequently ~)')
 
     if len(sys.argv[1:]) == 0:
         parser.print_help()