megadetector 5.0.29__py3-none-any.whl → 10.0.0__py3-none-any.whl

megadetector/visualization/visualization_utils.py

@@ -247,8 +247,13 @@ def load_image(input_file, ignore_exif_rotation=False):
     return image
 
 
-def resize_image(image, target_width=-1, target_height=-1, output_file=None,
-                 no_enlarge_width=False, verbose=False, quality='keep'):
+def resize_image(image,
+                 target_width=-1,
+                 target_height=-1,
+                 output_file=None,
+                 no_enlarge_width=False,
+                 verbose=False,
+                 quality='keep'):
     """
     Resizes a PIL Image object to the specified width and height; does not resize
     in place. If either width or height are -1, resizes with aspect ratio preservation.
@@ -378,7 +383,7 @@ def crop_image(detections, image, confidence_threshold=0.15, expansion=0):
 
         score = float(detection['conf'])
 
-        if score >= confidence_threshold:
+        if (confidence_threshold is None) or (score >= confidence_threshold):
 
             x1, y1, w_box, h_box = detection['bbox']
             ymin,xmin,ymax,xmax = y1, x1, y1 + h_box, x1 + w_box
@@ -422,6 +427,7 @@ def blur_detections(image,detections,blur_radius=40):
         image (PIL.Image.Image): image in which we should blur specific regions
         detections (list): list of detections in the MD output format, see render
             detection_bounding_boxes for more detail.
+        blur_radius (int, optional): radius of blur kernel in pixels
     """
 
     img_width, img_height = image.size
@@ -457,7 +463,7 @@ def render_detection_bounding_boxes(detections,
                                     image,
                                     label_map='show_categories',
                                     classification_label_map=None,
-                                    confidence_threshold=0,
+                                    confidence_threshold=0.0,
                                     thickness=DEFAULT_BOX_THICKNESS,
                                     expansion=0,
                                     classification_confidence_threshold=0.3,
@@ -531,7 +537,7 @@ def render_detection_bounding_boxes(detections,
             class names. The type of the numeric label (typically strings) needs to be consistent with the keys
             in label_map; no casting is  carried out. If [label_map] is None, no labels are shown (not even numbers
             and confidence values).
-        confidence_threshold (float or dict, optional), threshold above which boxes are rendered.  Can also be a
+        confidence_threshold (float or dict, optional): threshold above which boxes are rendered.  Can also be a
             dictionary mapping category IDs to thresholds.
         thickness (int, optional): line thickness in pixels
         expansion (int, optional): number of pixels to expand bounding boxes on each side
@@ -543,8 +549,8 @@ def render_detection_bounding_boxes(detections,
         textalign (int, optional): TEXTALIGN_LEFT, TEXTALIGN_CENTER, or TEXTALIGN_RIGHT
         vtextalign (int, optional): VTEXTALIGN_TOP or VTEXTALIGN_BOTTOM
         label_font_size (float, optional): font size for labels
-        custom_strings: optional set of strings to append to detection labels, should have the
-            same length as [detections].  Appended before any classification labels.
+        custom_strings (list of str, optional): optional set of strings to append to detection labels, should
+            have the same length as [detections].  Appended before any classification labels.
         box_sort_order (str, optional): sorting scheme for detection boxes, can be None, "confidence", or
             "reverse_confidence".
         verbose (bool, optional): enable additional debug output
@@ -587,7 +593,7 @@ def render_detection_bounding_boxes(detections,
 
         # Always render objects with a confidence of "None", this is typically used
         # for ground truth data.
-        if score is None or score >= rendering_threshold:
+        if (score is None) or (rendering_threshold is None) or (score >= rendering_threshold):
 
             x1, y1, w_box, h_box = detection['bbox']
             display_boxes.append([y1, x1, y1 + h_box, x1 + w_box])
@@ -668,10 +674,15 @@ def render_detection_bounding_boxes(detections,
     if verbose:
         print('Rendering {} of {} detections'.format(len(display_boxes),len(detections)))
 
-    draw_bounding_boxes_on_image(image, display_boxes, classes,
-                                 display_strs=display_strs, thickness=thickness,
-                                 expansion=expansion, colormap=colormap,
-                                 textalign=textalign, vtextalign=vtextalign,
+    draw_bounding_boxes_on_image(image,
+                                 display_boxes,
+                                 classes,
+                                 display_strs=display_strs,
+                                 thickness=thickness,
+                                 expansion=expansion,
+                                 colormap=colormap,
+                                 textalign=textalign,
+                                 vtextalign=vtextalign,
                                  label_font_size=label_font_size)
 
 # ...render_detection_bounding_boxes(...)
@@ -869,7 +880,7 @@ def draw_bounding_box_on_image(image,
 
         try:
             font = ImageFont.truetype('arial.ttf', label_font_size)
-        except IOError:
+        except OSError:
             font = ImageFont.load_default()
 
         display_str_heights = [get_text_size(font,ds)[1] for ds in display_str_list]
@@ -1015,14 +1026,16 @@ def render_db_bounding_boxes(boxes,
                              vtextalign=VTEXTALIGN_TOP,
                              text_rotation=None,
                              label_font_size=DEFAULT_LABEL_FONT_SIZE,
-                             tags=None):
+                             tags=None,
+                             boxes_are_normalized=False):
     """
     Render bounding boxes (with class labels) on an image.  This is a wrapper for
     draw_bounding_boxes_on_image, allowing the caller to operate on a resized image
     by providing the original size of the image; boxes will be scaled accordingly.
 
     This function assumes that bounding boxes are in absolute coordinates, typically
-    because they come from COCO camera traps .json files.
+    because they come from COCO camera traps .json files, unless boxes_are_normalized
+    is True.
 
     Args:
         boxes (list): list of length-4 tuples, foramtted as (x,y,w,h) (in pixels)
@@ -1045,6 +1058,7 @@ def render_db_bounding_boxes(boxes,
         label_font_size (float, optional): font size for labels
         tags (list, optional): list of strings of length len(boxes) that should be appended
             after each class name (e.g. to show scores)
+        boxes_are_normalized (bool, optional): whether boxes have already been normalized
     """
 
     display_boxes = []
@@ -1064,11 +1078,21 @@ def render_db_bounding_boxes(boxes,
 
         x_min_abs, y_min_abs, width_abs, height_abs = box[0:4]
 
-        ymin = y_min_abs / img_height
-        ymax = ymin + height_abs / img_height
+        # Normalize boxes if necessary
+        if boxes_are_normalized:
 
-        xmin = x_min_abs / img_width
-        xmax = xmin + width_abs / img_width
+            xmin = x_min_abs
+            xmax = x_min_abs + width_abs
+            ymin = y_min_abs
+            ymax = y_min_abs + height_abs
+
+        else:
+
+            ymin = y_min_abs / img_height
+            ymax = ymin + height_abs / img_height
+
+            xmin = x_min_abs / img_width
+            xmax = xmin + width_abs / img_width
 
         display_boxes.append([ymin, xmin, ymax, xmax])
 
@@ -1121,10 +1145,12 @@ def draw_bounding_boxes_on_file(input_file,
 
     Args:
         input_file (str): filename or URL to load
-        output_file (str, optional): filename to which we should write the rendered image
+        output_file (str): filename to which we should write the rendered image
         detections (list): a list of dictionaries with keys 'conf', 'bbox', and 'category';
             boxes are length-four arrays formatted as [x,y,w,h], normalized,
             upper-left origin (this is the standard MD detection format). 'category' is a string-int.
+        confidence_threshold (float, optional): only render detections with confidence above this
+            threshold
         detector_label_map (dict, optional): a dict mapping category IDs to strings.  If this
             is None, no confidence values or identifiers are shown.  If this is {}, just category
             indices and confidence values are shown.
@@ -1150,10 +1176,15 @@ def draw_bounding_boxes_on_file(input_file,
         image = resize_image(image,target_size[0],target_size[1])
 
     render_detection_bounding_boxes(
-            detections, image, label_map=detector_label_map,
+            detections,
+            image,
+            label_map=detector_label_map,
             confidence_threshold=confidence_threshold,
-            thickness=thickness,expansion=expansion,colormap=colormap,
-            custom_strings=custom_strings,label_font_size=label_font_size)
+            thickness=thickness,
+            expansion=expansion,
+            colormap=colormap,
+            custom_strings=custom_strings,
+            label_font_size=label_font_size)
 
     if output_file is not None:
         image.save(output_file)
@@ -1196,8 +1227,13 @@ def draw_db_boxes_on_file(input_file,
     if classes is None:
         classes = [0] * len(boxes)
 
-    render_db_bounding_boxes(boxes, classes, image, original_size=None,
-                             label_map=label_map, thickness=thickness, expansion=expansion)
+    render_db_bounding_boxes(boxes,
+                             classes,
+                             image,
+                             original_size=None,
+                             label_map=label_map,
+                             thickness=thickness,
+                             expansion=expansion)
 
     image.save(output_file)
 
@@ -1215,8 +1251,8 @@ def gray_scale_fraction(image,crop_size=(0.1,0.1)):
 
     Args:
         image (str or PIL.Image.Image): Image, filename, or URL to analyze
-        crop_size (optional): a 2-element list/tuple, representing the fraction of the
-            image to crop at the top and bottom, respectively, before analyzing (to minimize
+        crop_size (tuple of floats, optional): a 2-element list/tuple, representing the fraction of
+            the image to crop at the top and bottom, respectively, before analyzing (to minimize
             the possibility of including color elements in the image overlay)
 
     Returns:
@@ -1283,14 +1319,14 @@ def gray_scale_fraction(image,crop_size=(0.1,0.1)):
 
 
 def _resize_relative_image(fn_relative,
-                          input_folder,
-                          output_folder,
-                          target_width,
-                          target_height,
-                          no_enlarge_width,
-                          verbose,
-                          quality,
-                          overwrite=True):
+                           input_folder,
+                           output_folder,
+                           target_width,
+                           target_height,
+                           no_enlarge_width,
+                           verbose,
+                           quality,
+                           overwrite=True):
     """
     Internal function for resizing an image from one folder to another,
     maintaining relative path.
@@ -1308,8 +1344,11 @@ def _resize_relative_image(fn_relative,
     try:
         _ = resize_image(input_fn_abs,
                          output_file=output_fn_abs,
-                         target_width=target_width, target_height=target_height,
-                         no_enlarge_width=no_enlarge_width, verbose=verbose, quality=quality)
+                         target_width=target_width,
+                         target_height=target_height,
+                         no_enlarge_width=no_enlarge_width,
+                         verbose=verbose,
+                         quality=quality)
         status = 'success'
         error = None
     except Exception as e:
@@ -1324,7 +1363,11 @@ def _resize_relative_image(fn_relative,
 
 
 def _resize_absolute_image(input_output_files,
-                          target_width,target_height,no_enlarge_width,verbose,quality):
+                           target_width,
+                           target_height,
+                           no_enlarge_width,
+                           verbose,
+                           quality):
     """
     Internal wrapper for resize_image used in the context of a batch resize operation.
     """
@@ -1335,8 +1378,11 @@ def _resize_absolute_image(input_output_files,
     try:
         _ = resize_image(input_fn_abs,
                          output_file=output_fn_abs,
-                         target_width=target_width, target_height=target_height,
-                         no_enlarge_width=no_enlarge_width, verbose=verbose, quality=quality)
+                         target_width=target_width,
+                         target_height=target_height,
+                         no_enlarge_width=no_enlarge_width,
+                         verbose=verbose,
+                         quality=quality)
         status = 'success'
         error = None
     except Exception as e:
@@ -1544,7 +1590,8 @@ def resize_image_folder(input_folder,
                 quality=quality,
                 overwrite=overwrite)
 
-        results = list(tqdm(pool.imap(p, image_files_relative),total=len(image_files_relative)))
+        results = list(tqdm(pool.imap(p, image_files_relative),
+                            total=len(image_files_relative)))
 
     return results
 
@@ -1557,6 +1604,7 @@ def get_image_size(im,verbose=False):
 
     Args:
         im (str or PIL.Image): filename or PIL image
+        verbose (bool, optional): enable additional debug output
 
     Returns:
         tuple (w,h), or None if the image fails to load.
@@ -1600,13 +1648,13 @@ def parallel_get_image_sizes(filenames,
             parallelization
         use_threads (bool, optional): whether to use threads (True) or processes (False) for
             parallelization
-        recursive (bool, optional): if [filenames] is a folder, whether to search recursively for images.
-            Ignored if [filenames] is a list.
+        recursive (bool, optional): if [filenames] is a folder, whether to search recursively
+            for images. Ignored if [filenames] is a list.
         verbose (bool, optional): enable additional debug output
 
     Returns:
         dict: a dict mapping filenames to (w,h) tuples; the value will be None for images that fail
-        to load.
+        to load.  Filenames will always be absolute.
     """
 
     if isinstance(filenames,str) and os.path.isdir(filenames):
@@ -1707,7 +1755,7 @@ def check_image_integrity(filename,modes=None):
         elif mode == 'skimage':
             try:
                 # This is not a standard dependency
-                from skimage import io as skimage_io # noqa
+                from skimage import io as skimage_io # type: ignore # noqa
             except Exception:
                 result[mode] = 'could not import skimage, run pip install scikit-image'
                 return result
@@ -1747,7 +1795,7 @@ def parallel_check_image_integrity(filenames,
 
     Args:
         filenames (list or str): a list of image filenames or a folder
-        mode (list): see check_image_integrity() for documentation on the [modes] parameter
+        modes (list, optional): see check_image_integrity() for documentation on the [modes] parameter
         max_workers (int, optional): the number of parallel workers to use; set to <=1 to disable
             parallelization
         use_threads (bool, optional): whether to use threads (True) or processes (False) for

megadetector/visualization/visualize_db.py

@@ -162,6 +162,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
 
     Args:
         db_path (str or dict): the .json filename to load, or a previously-loaded database
+        output_dir (str): the folder to which we should write annotated images
         image_base_dir (str): the folder where the images live; filenames in [db_path] should
             be relative to this folder.
         options (DbVizOptions, optional): See DbVizOptions for details
@@ -211,8 +212,11 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
 
         b_has_bbox = [False] * len(annotations)
         for i_ann,ann in enumerate(annotations):
-            if 'bbox' in ann:
-                assert isinstance(ann['bbox'],list)
+            if 'bbox' in ann or 'bbox_relative' in ann:
+                if 'bbox' in ann:
+                    assert isinstance(ann['bbox'],list)
+                else:
+                    assert isinstance(ann['bbox_relative'],list)
                 b_has_bbox[i_ann] = True
         annotations_with_boxes = list(compress(annotations, b_has_bbox))
 
@@ -323,6 +327,9 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         extra_annotation_field_string = ''
         annotation_level_for_image = ''
 
+        # Did this image come with already-normalized bounding boxes?
+        boxes_are_normalized = None
+
         # Iterate over annotations for this image
         # i_ann = 0; anno = annos_i.iloc[i_ann]
         for i_ann,anno in annos_i.iterrows():
@@ -363,8 +370,22 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
                     category_name,category_name)
             image_categories.add(category_name)
 
-            if 'bbox' in anno:
-                bbox = anno['bbox']
+            assert not ('bbox' in anno and 'bbox_relative' in anno), \
+                "An annotation can't have both an absolute and a relative bounding box"
+
+            box_field = 'bbox'
+            if 'bbox_relative' in anno:
+                box_field = 'bbox_relative'
+                assert (boxes_are_normalized is None) or (boxes_are_normalized), \
+                    "An image can't have both absolute and relative bounding boxes"
+                boxes_are_normalized = True
+            elif 'bbox' in anno:
+                assert (boxes_are_normalized is None) or (not boxes_are_normalized), \
+                    "An image can't have both absolute and relative bounding boxes"
+                boxes_are_normalized = False
+
+            if box_field in anno:
+                bbox = anno[box_field]
                 if isinstance(bbox,float):
                     assert math.isnan(bbox), "I shouldn't see a bbox that's neither a box nor NaN"
                     continue
@@ -394,7 +415,8 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
                                      'box_classes':box_classes,
                                      'tags':box_score_strings,
                                      'img_path':img_path,
-                                     'output_file_name':file_name}
+                                     'output_file_name':file_name,
+                                     'boxes_are_normalized':boxes_are_normalized}
         rendering_info.append(rendering_info_this_image)
 
         label_level_string = ''
@@ -454,6 +476,7 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         img_path = rendering_info['img_path']
         bboxes = rendering_info['bboxes']
         bbox_classes = rendering_info['box_classes']
+        boxes_are_normalized = rendering_info['boxes_are_normalized']
         bbox_tags = None
         if 'tags' in rendering_info:
             bbox_tags = rendering_info['tags']
@@ -473,11 +496,14 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
         try:
             original_image = vis_utils.open_image(img_path)
             original_size = original_image.size
-            if (options.viz_size is None) or (options.viz_size[0] == -1 and options.viz_size[1] == -1):
+            if (options.viz_size is None) or \
+                (options.viz_size[0] == -1 and options.viz_size[1] == -1):
                 image = original_image
             else:
-                image = vis_utils.resize_image(original_image, options.viz_size[0],
-                                               options.viz_size[1])
+                image = vis_utils.resize_image(original_image,
+                                               options.viz_size[0],
+                                               options.viz_size[1],
+                                               no_enlarge_width=True)
         except Exception as e:
             print('Image {} failed to open, error: {}'.format(img_path, e))
             return False
@@ -489,7 +515,8 @@ def visualize_db(db_path, output_dir, image_base_dir, options=None):
                                            label_map=label_map,
                                            thickness=options.box_thickness,
                                            expansion=options.box_expansion,
-                                           tags=bbox_tags)
+                                           tags=bbox_tags,
+                                           boxes_are_normalized=boxes_are_normalized)
 
         image.save(output_full_path)
 

megadetector/visualization/visualize_detector_output.py

@@ -161,7 +161,7 @@ def visualize_detector_output(detector_output_path,
     Args:
         detector_output_path (str): path to detector output .json file
         out_dir (str): path to directory for saving annotated images
-        images_dir (str): folder where the images live; filenames in
+        images_dir (str, optional): folder where the images live; filenames in
             [detector_output_path] should be relative to [image_dir].  Can be None if paths are
             absolute.
         confidence_threshold (float, optional): threshold above which detections will be rendered
@@ -169,9 +169,9 @@ def visualize_detector_output(detector_output_path,
         output_image_width (int, optional): width in pixels to resize images for display,
             preserving aspect ration; set to -1 to use original image width
         random_seed (int, optional): seed to use for choosing images when sample != -1
-        render_detections_only (bool): only render images with above-threshold detections.  Empty
-            images are discarded after sampling, so if you want to see, e.g., 1000 non-empty images,
-            you can set [render_detections_only], but you need to sample more than 1000 images.
+        render_detections_only (bool, optional): only render images with above-threshold detections.
+            Empty images are discarded after sampling, so if you want to see, e.g., 1000 non-empty
+            images, you can set [render_detections_only], but you need to sample more than 1000 images.
         classification_confidence_threshold (float, optional): only show classifications
             above this threshold; does not impact whether images are rendered, only whether
             classification labels (not detection categories) are displayed