megadetector 5.0.6__py3-none-any.whl → 5.0.8__py3-none-any.whl

md_visualization/visualization_utils.py

@@ -8,22 +8,32 @@
 
 #%% Constants and imports
 
-from io import BytesIO
-from typing import Union
 import time
-
-import matplotlib.pyplot as plt
 import numpy as np
 import requests
+import os
+
+from io import BytesIO
+from typing import Union
 from PIL import Image, ImageFile, ImageFont, ImageDraw
+from multiprocessing.pool import ThreadPool
+from multiprocessing.pool import Pool
+from tqdm import tqdm
+from functools import partial
+
+from md_utils.path_utils import find_images
 
 from data_management.annotations import annotation_constants
 from data_management.annotations.annotation_constants import (
-    detector_bbox_category_id_to_name)  # here id is int
+    detector_bbox_category_id_to_name)
 
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 
-IMAGE_ROTATIONS = {
+# Maps EXIF standard rotation identifiers to degrees.  The value "1" indicates no
+# rotation; this will be ignored.  The values 2, 4, 5, and 7 are mirrored rotations,
+# which are not supported (we'll assert() on this when we apply rotations).
+EXIF_IMAGE_NO_ROTATION = 1
+EXIF_IMAGE_ROTATIONS = {
     3: 180,
     6: 270,
     8: 90
@@ -32,7 +42,7 @@ IMAGE_ROTATIONS = {
 TEXTALIGN_LEFT = 0
 TEXTALIGN_RIGHT = 1
 
-# convert category ID from int to str
+# Convert category ID from int to str
 DEFAULT_DETECTOR_LABEL_MAP = {
     str(k): v for k, v in detector_bbox_category_id_to_name.items()
 }
@@ -48,7 +58,7 @@ DEFAULT_LABEL_FONT_SIZE = 16
 
 #%% Functions
 
-def open_image(input_file: Union[str, BytesIO]) -> Image:
+def open_image(input_file: Union[str, BytesIO], ignore_exif_rotation=False) -> Image:
     """
     Opens an image in binary format using PIL.Image and converts to RGB mode.
     
@@ -56,7 +66,7 @@ def open_image(input_file: Union[str, BytesIO]) -> Image:
 
     This operation is lazy; image will not be actually loaded until the first
     operation that needs to load it (for example, resizing), so file opening
-    errors can show up later.
+    errors can show up later.  load_image() is the non-lazy version of this function.
 
     Args:
         input_file: str or BytesIO, either a path to an image file (anything
@@ -101,23 +111,28 @@ def open_image(input_file: Union[str, BytesIO]) -> Image:
         # PIL.Image.convert() returns a converted copy of this image
         image = image.convert(mode='RGB')
 
-    # Alter orientation as needed according to EXIF tag 0x112 (274) for Orientation
-    #
-    # https://gist.github.com/dangtrinhnt/a577ece4cbe5364aad28
-    # https://www.media.mit.edu/pia/Research/deepview/exif.html
-    #
-    try:
-        exif = image._getexif()
-        orientation: int = exif.get(274, None)  # 274 is the key for the Orientation field
-        if orientation is not None and orientation in IMAGE_ROTATIONS:
-            image = image.rotate(IMAGE_ROTATIONS[orientation], expand=True)  # returns a rotated copy
-    except Exception:
-        pass
+    if not ignore_exif_rotation:
+        # Alter orientation as needed according to EXIF tag 0x112 (274) for Orientation
+        #
+        # https://gist.github.com/dangtrinhnt/a577ece4cbe5364aad28
+        # https://www.media.mit.edu/pia/Research/deepview/exif.html
+        #
+        try:
+            exif = image._getexif()
+            orientation: int = exif.get(274, None)  
+            if (orientation is not None) and (orientation != EXIF_IMAGE_NO_ROTATION):
+                assert orientation in EXIF_IMAGE_ROTATIONS, \
+                    'Mirrored rotations are not supported'
+                image = image.rotate(EXIF_IMAGE_ROTATIONS[orientation], expand=True)  
+        except Exception:
+            pass
 
     return image
 
+# ...def open_image(...)
+
 
-def exif_preserving_save(pil_image,output_file):
+def exif_preserving_save(pil_image,output_file,quality='keep',default_quality=85,verbose=False):
     """
     Save [pil_image] to [output_file], making a moderate attempt to preserve EXIF
     data and JPEG quality.  Neither is guaranteed.
@@ -127,27 +142,50 @@ def exif_preserving_save(pil_image,output_file):
     https://discuss.dizzycoding.com/determining-jpg-quality-in-python-pil/
      
     ...for more ways to preserve jpeg quality if quality='keep' doesn't do the trick.
+
+    The "quality" parameter should be "keep" (default), or an integer from 0 to 100. 
+    This is only used if PIL thinks the the source image is a JPEG.  If you load a JPEG
+    and resize it in memory, for example, it's no longer a JPEG.
+    
+    'default_quality' is used when quality == 'keep' and we are saving a non-JPEG source.
+    'keep' is only supported for JPEG sources.
     """
     
     # Read EXIF metadata
     exif = pil_image.info['exif'] if ('exif' in pil_image.info) else None
     
-    # Write output with EXIF metadata if available, and quality='keep' if this is a JPEG
-    # image.  Unfortunately, neither parameter likes "None", so we get a slightly
-    # icky cascade of if's here.
-    if exif is not None:
-        if pil_image.format == "JPEG":
-            pil_image.save(output_file, exif=exif, quality='keep')
+    # Quality preservation is only supported for JPEG sources.
+    if pil_image.format != "JPEG":
+        if quality == 'keep':
+            if verbose:
+                print('Warning: quality "keep" passed when saving a non-JPEG source (during save to {})'.format(
+                    output_file))
+            quality = default_quality            
+    
+    # Some output formats don't support the quality parameter, so we try once with, 
+    # and once without.  This is a horrible cascade of if's, but it's a consequence of
+    # the fact that "None" is not supported for either "exif" or "quality".
+        
+    try:
+        
+        if exif is not None:
+            pil_image.save(output_file, exif=exif, quality=quality)
         else:
-            pil_image.save(output_file, exif=exif)
-    else:
-        if pil_image.format == "JPEG":            
-            pil_image.save(output_file, quality='keep')
+            pil_image.save(output_file, quality=quality)
+                
+    except Exception:
+        
+        if verbose:
+            print('Warning: failed to write {}, trying again without quality parameter'.format(output_file))
+        if exif is not None:
+            pil_image.save(output_file, exif=exif)            
         else:
             pil_image.save(output_file)
             
-            
-def load_image(input_file: Union[str, BytesIO]) -> Image:
+# ...def exif_preserving_save(...)
+
+
+def load_image(input_file: Union[str, BytesIO], ignore_exif_rotation=False) -> Image:
     """
     Loads the image at input_file as a PIL Image into memory.
 
@@ -161,27 +199,49 @@ def load_image(input_file: Union[str, BytesIO]) -> Image:
     Returns: PIL.Image.Image, in RGB mode
     """
     
-    image = open_image(input_file)
+    image = open_image(input_file, ignore_exif_rotation=ignore_exif_rotation)
     image.load()
     return image
 
 
-def resize_image(image, target_width, target_height=-1, output_file=None):
+def resize_image(image, target_width, 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.
-    If both are -1, returns the original image (does not copy in this case).
+    
+    None is equivalent to -1 for target_width and target_height.
     
     [image] can be a PIL image or a filename.
+    
+    If target_width and target_height are both -1, does not modify the image, but 
+    will write to output_file if supplied.
+    
+    If no_enlarge_width is True, and the target width is larger than the original
+    image width, does not modify the image, but will write to output_file if supplied.
+    
+    'quality' is passed to exif_preserving_save, see docs there.
     """
 
+    image_fn = 'in_memory'
     if isinstance(image,str):
+        image_fn = image
         image = load_image(image)
         
-    # Null operation
+    if target_width is None:
+        target_width = -1
+    
+    if target_height is None:
+        target_height = -1
+    
+    resize_required = True
+        
+    # No resize was requested, this is always a no-op
     if target_width == -1 and target_height == -1:
-        return image
-
+        
+        resize_required = False
+    
+    # Does either dimension need to scale according to the other?
     elif target_width == -1 or target_height == -1:
 
         # Aspect ratio as width over height
@@ -194,39 +254,46 @@ def resize_image(image, target_width, target_height=-1, output_file=None):
         else:
             # w = ar * h
             target_width = int(aspect_ratio * target_height)
-
-    # This parameter changed between Pillow versions 9 and 10, and for a bit, I'd like to
-    # support both.
+    
+    # If we're not enlarging images and this would be an enlarge operation
+    if (no_enlarge_width) and (target_width > image.size[0]):
+        
+        if verbose:
+            print('Bypassing image enlarge for {} --> {}'.format(
+                image_fn,str(output_file)))
+        resize_required = False
+        
+    # If the target size is the same as the original size
+    if (target_width == image.size[0]) and (target_height == image.size[1]):
+        
+        resize_required = False    
+    
+    if not resize_required:
+        
+        if output_file is not None:
+            if verbose:
+                print('No resize required for resize {} --> {}'.format(
+                    image_fn,str(output_file)))
+            exif_preserving_save(image,output_file,quality=quality,verbose=verbose)
+        return image
+    
+    assert target_width > 0 and target_height > 0, \
+        'Invalid image resize target {},{}'.format(target_width,target_height)
+        
+    # The antialiasing parameter changed between Pillow versions 9 and 10, and for a bit, 
+    # I'd like to support both.
     try:
         resized_image = image.resize((target_width, target_height), Image.ANTIALIAS)
     except:
         resized_image = image.resize((target_width, target_height), Image.Resampling.LANCZOS)
         
     if output_file is not None:
-        exif_preserving_save(resized_image,output_file)
+        exif_preserving_save(resized_image,output_file,quality=quality,verbose=verbose)
         
     return resized_image
 
+# ...def resize_image(...)
 
-def show_images_in_a_row(images):
-
-    num = len(images)
-    assert num > 0
-
-    if isinstance(images[0], str):
-        images = [Image.open(img) for img in images]
-
-    fig, axarr = plt.subplots(1, num, squeeze=False)  # number of rows, number of columns
-    fig.set_size_inches((num * 5, 25))  # each image is 2 inches wide
-    for i, img in enumerate(images):
-        axarr[0, i].set_axis_off()
-        axarr[0, i].imshow(img)
-    return fig
-
-
-# The following three functions are modified versions of those at:
-#
-# https://github.com/tensorflow/models/blob/master/research/object_detection/utils/visualization_utils.py
 
 DEFAULT_COLORS = [
     'AliceBlue', 'Red', 'RoyalBlue', 'Gold', 'Chartreuse', 'Aqua', 'Azure',
@@ -365,13 +432,15 @@ def render_detection_bounding_boxes(detections, image,
 
         label_map: optional, mapping the numerical label to a string name. The type of the numerical label
             (default string) needs to be consistent with the keys in label_map; no casting is carried out.
-            If this is None, no labels are shown.
+            If this is None, no labels are shown (not even numbers and confidence values).  If you want
+            category numbers and confidence values without class labels, use {}.
 
         classification_label_map: optional, mapping of the string class labels to the actual class names.
             The type of the numerical label (default string) needs to be consistent with the keys in
             label_map; no casting is carried out.  If this is None, no classification labels are shown.
 
-        confidence_threshold: optional, threshold above which the bounding box is rendered.
+        confidence_threshold: optional, threshold above which boxes are rendered.  Can also be a dictionary
+        mapping category IDs to thresholds.
         
         thickness: line thickness in pixels. Default value is 4.
         
@@ -405,9 +474,15 @@ def render_detection_bounding_boxes(detections, image,
 
         score = detection['conf']
         
+        if isinstance(confidence_threshold,dict):
+            rendering_threshold = confidence_threshold[detection['category']]
+        else:
+            rendering_threshold = confidence_threshold        
+            
+            
         # Always render objects with a confidence of "None", this is typically used
         # for ground truth data.        
-        if score is None or score >= confidence_threshold:
+        if score 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])
@@ -476,6 +551,8 @@ def render_detection_bounding_boxes(detections, image,
                                  expansion=expansion, colormap=colormap, textalign=textalign,
                                  label_font_size=label_font_size)
 
+# ...render_detection_bounding_boxes(...)
+
 
 def draw_bounding_boxes_on_image(image,
                                  boxes,
@@ -522,6 +599,8 @@ def draw_bounding_boxes_on_image(image,
                                        textalign=textalign,
                                        label_font_size=label_font_size)
 
+# ...draw_bounding_boxes_on_image(...)
+
 
 def draw_bounding_box_on_image(image,
                                ymin,
@@ -552,8 +631,9 @@ def draw_bounding_box_on_image(image,
     ymin: ymin of bounding box - upper left.
     xmin: xmin of bounding box.
     ymax: ymax of bounding box.
-    xmax: xmax of bounding box.
-    clss: str, the class of the object in this bounding box - will be cast to an int.
+    xmax: xmax of bounding box.    
+    clss: str, the class of the object in this bounding box; should be either an integer
+        or a string-formatted integer.
     thickness: line thickness. Default value is 4.
     expansion: number of pixels to expand bounding boxes on each side.  Default is 0.
     display_str_list: list of strings to display in box
@@ -561,10 +641,15 @@ def draw_bounding_box_on_image(image,
         use_normalized_coordinates: If True (default), treat coordinates
         ymin, xmin, ymax, xmax as relative to the image.  Otherwise treat
         coordinates as absolute.
-    label_font_size: font size to attempt to load arial.ttf with
+    label_font_size: font size 
+    
+    Adapted from:
+        
+    https://github.com/tensorflow/models/blob/master/research/object_detection/utils/visualization_utils.py
     """
     
     if clss is None:
+        # Default to the MegaDetector animal class ID (1)
         color = colormap[1]
     else:
         color = colormap[int(clss) % len(colormap)]
@@ -670,6 +755,8 @@ def draw_bounding_box_on_image(image,
 
         text_bottom -= (text_height + 2 * margin)
 
+# ...def draw_bounding_box_on_image(...)
+
 
 def render_iMerit_boxes(boxes, classes, image,
                         label_map=annotation_constants.annotation_bbox_category_id_to_name):
@@ -743,6 +830,8 @@ def render_megadb_bounding_boxes(boxes_info, image):
     display_boxes = np.array(display_boxes)
     draw_bounding_boxes_on_image(image, display_boxes, classes, display_strs=display_strs)
 
+# ...def render_iMerit_boxes(...)
+
 
 def render_db_bounding_boxes(boxes, classes, image, original_size=None,
                              label_map=None, thickness=DEFAULT_BOX_THICKNESS, expansion=0):
@@ -787,13 +876,16 @@ def render_db_bounding_boxes(boxes, classes, image, original_size=None,
     draw_bounding_boxes_on_image(image, display_boxes, classes, display_strs=display_strs,
                                  thickness=thickness, expansion=expansion)
 
+# ...def render_db_bounding_boxes(...)
+
 
 def draw_bounding_boxes_on_file(input_file, output_file, detections, confidence_threshold=0.0,
                                 detector_label_map=DEFAULT_DETECTOR_LABEL_MAP,
                                 thickness=DEFAULT_BOX_THICKNESS, expansion=0,
                                 colormap=DEFAULT_COLORS,
                                 label_font_size=DEFAULT_LABEL_FONT_SIZE,
-                                custom_strings=None,target_size=None):
+                                custom_strings=None,target_size=None,
+                                ignore_exif_rotation=False):
     """
     Render detection bounding boxes on an image loaded from file, writing the results to a
     new image file.
@@ -808,7 +900,9 @@ def draw_bounding_boxes_on_file(input_file, output_file, detections, confidence_
     
     Normalized, with the origin at the upper-left.
     
-    detector_label_map is a dict mapping category IDs to strings.
+    detector_label_map is 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.
     
     custom_strings: optional set of strings to append to detection labels, should have the
     same length as [detections].  Appended before classification labels, if classification
@@ -818,7 +912,7 @@ def draw_bounding_boxes_on_file(input_file, output_file, detections, confidence_
     see resize_image for documentation.  If None or (-1,-1), uses the original image size.
     """
     
-    image = open_image(input_file)
+    image = open_image(input_file, ignore_exif_rotation=ignore_exif_rotation)
     
     if target_size is not None:
         image = resize_image(image,target_size[0],target_size[1])
@@ -833,7 +927,8 @@ def draw_bounding_boxes_on_file(input_file, output_file, detections, confidence_
 
 
 def draw_db_boxes_on_file(input_file, output_file, boxes, classes=None, 
-                          label_map=None, thickness=DEFAULT_BOX_THICKNESS, expansion=0):
+                          label_map=None, thickness=DEFAULT_BOX_THICKNESS, expansion=0,
+                          ignore_exif_rotation=False):
     """
     Render COCO bounding boxes (in absolute coordinates) on an image loaded from file, writing the
     results to a new image file.
@@ -843,7 +938,7 @@ def draw_db_boxes_on_file(input_file, output_file, boxes, classes=None,
     detector_label_map is a dict mapping category IDs to strings.
     """
     
-    image = open_image(input_file)
+    image = open_image(input_file, ignore_exif_rotation=ignore_exif_rotation)
 
     if classes is None:
         classes = [0] * len(boxes)
@@ -854,6 +949,9 @@ def draw_db_boxes_on_file(input_file, output_file, boxes, classes=None,
     image.save(output_file)
     
 
+# ...def draw_bounding_boxes_on_file(...)
+
+
 def gray_scale_fraction(image,crop_size=(0.1,0.1)):
     """
     Returns the fraction of the pixels in [image] that appear to be grayscale (R==G==B), 
@@ -923,3 +1021,211 @@ def gray_scale_fraction(image,crop_size=(0.1,0.1)):
                 r, g, b = image.getpixel((i,j))
                 if r == g and r == b and g == b:
                     n_gray_pixels += 1            
+
+
+# ...def gray_scale_fraction(...)
+
+
+def _resize_relative_image(fn_relative,
+                          input_folder,output_folder,
+                          target_width,target_height,no_enlarge_width,verbose,quality):
+    """
+    Internal function for resizing an image from one folder to another,
+    maintaining relative path.
+    """
+    
+    input_fn_abs = os.path.join(input_folder,fn_relative)
+    output_fn_abs = os.path.join(output_folder,fn_relative)
+    os.makedirs(os.path.dirname(output_fn_abs),exist_ok=True)
+    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)
+        status = 'success'
+        error = None
+    except Exception as e:
+        if verbose:
+            print('Error resizing {}: {}'.format(fn_relative,str(e)))
+        status = 'error'
+        error = str(e)
+        
+    return {'fn_relative':fn_relative,'status':status,'error':error}
+
+# ...def _resize_relative_image(...)
+
+
+def _resize_absolute_image(input_output_files,
+                          target_width,target_height,no_enlarge_width,verbose,quality):
+    
+    """
+    Internal wrappter for resize_image used in the context of a batch resize operation.
+    """
+    
+    input_fn_abs = input_output_files[0]
+    output_fn_abs = input_output_files[1]
+    os.makedirs(os.path.dirname(output_fn_abs),exist_ok=True)
+    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)
+        status = 'success'
+        error = None
+    except Exception as e:
+        if verbose:
+            print('Error resizing {}: {}'.format(input_fn_abs,str(e)))
+        status = 'error'
+        error = str(e)
+        
+    return {'input_fn':input_fn_abs,'output_fn':output_fn_abs,status:'status',
+            'error':error}
+
+# ..._resize_absolute_image(...)
+
+
+def resize_images(input_file_to_output_file,
+                  target_width=-1, target_height=-1,
+                  no_enlarge_width=False, verbose=False, quality='keep',
+                  pool_type='process', n_workers=10):
+    """
+    Resize all images the dictionary [input_file_to_output_file].
+    
+    Defaults to parallelizing across processes.
+    
+    See resize_image() for parameter information.
+    
+    TODO: This is a little more redundant with resize_image_folder than I would like;
+    refactor resize_image_folder to call resize_images.  Not doing that yet because
+    at the time I'm writing this comment, a lot of code depends on resize_image_folder 
+    and I don't want to rock the boat yet.
+    """
+
+    
+    assert pool_type in ('process','thread'), 'Illegal pool type {}'.format(pool_type)
+    
+    input_output_file_pairs = []
+    
+    # Reformat input files as (input,output) tuples
+    for input_fn in input_file_to_output_file:
+        input_output_file_pairs.append((input_fn,input_file_to_output_file[input_fn]))
+    
+    if n_workers == 1:    
+        
+        results = []
+        for i_o_file_pair in tqdm(input_output_file_pairs):
+            results.append(_resize_absolute_image(i_o_file_pair,
+                            target_width=target_width,
+                            target_height=target_height,
+                            no_enlarge_width=no_enlarge_width,
+                            verbose=verbose,
+                            quality=quality))
+
+    else:
+        
+        if pool_type == 'thread':
+            pool = ThreadPool(n_workers); poolstring = 'threads'                
+        else:
+            assert pool_type == 'process'
+            pool = Pool(n_workers); poolstring = 'processes'
+        
+        if verbose:
+            print('Starting resizing pool with {} {}'.format(n_workers,poolstring))
+        
+        p = partial(_resize_absolute_image,
+                target_width=target_width,
+                target_height=target_height,
+                no_enlarge_width=no_enlarge_width,
+                verbose=verbose,
+                quality=quality)
+        
+        results = list(tqdm(pool.imap(p, input_output_file_pairs),total=len(input_output_file_pairs)))
+
+    return results
+
+# ...def resize_images(...)
+
+
+def resize_image_folder(input_folder, output_folder=None,
+                        target_width=-1, target_height=-1,
+                        no_enlarge_width=False, verbose=False, quality='keep',
+                        pool_type='process', n_workers=10, recursive=True,
+                        image_files_relative=None):
+    """
+    Resize all images in a folder (defaults to recursive)
+    
+    Defaults to in-place resizing (output_folder is optional).
+    
+    Defaults to parallelizing across processes.
+    
+    See resize_image() for parameter information.
+    """
+
+    assert os.path.isdir(input_folder), '{} is not a folder'.format(input_folder)
+    
+    if output_folder is None:
+        output_folder = input_folder
+    else:
+        os.makedirs(output_folder,exist_ok=True)
+        
+    assert pool_type in ('process','thread'), 'Illegal pool type {}'.format(pool_type)
+    
+    if image_files_relative is None:
+        image_files_relative = find_images(input_folder,recursive=recursive,return_relative_paths=True)
+        if verbose:
+            print('Found {} images'.format(len(image_files_relative)))
+    
+    if n_workers == 1:    
+        
+        results = []
+        for fn_relative in tqdm(image_files_relative):
+            results.append(_resize_relative_image(fn_relative,
+                                  input_folder=input_folder,
+                                  output_folder=output_folder,
+                                  target_width=target_width,
+                                  target_height=target_height,
+                                  no_enlarge_width=no_enlarge_width,
+                                  verbose=verbose,
+                                  quality=quality))
+
+    else:
+        
+        if pool_type == 'thread':
+            pool = ThreadPool(n_workers); poolstring = 'threads'                
+        else:
+            assert pool_type == 'process'
+            pool = Pool(n_workers); poolstring = 'processes'
+        
+        if verbose:
+            print('Starting resizing pool with {} {}'.format(n_workers,poolstring))
+        
+        p = partial(_resize_relative_image,
+                input_folder=input_folder,
+                output_folder=output_folder,
+                target_width=target_width,
+                target_height=target_height,
+                no_enlarge_width=no_enlarge_width,
+                verbose=verbose,
+                quality=quality)
+        
+        results = list(tqdm(pool.imap(p, image_files_relative),total=len(image_files_relative)))
+
+    return results
+
+# ...def resize_image_folder(...)
+
+
+#%% Test drivers
+
+if False:
+    
+    #%% Recursive resize test
+    
+    from md_visualization.visualization_utils import resize_image_folder # noqa
+    
+    input_folder = r"C:\temp\resize-test\in"
+    output_folder = r"C:\temp\resize-test\out"
+    
+    resize_results = resize_image_folder(input_folder,output_folder,
+                         target_width=1280,verbose=True,quality=85,no_enlarge_width=True,
+                         pool_type='process',n_workers=10)