Add zoomout operation

Author: gachiemchiep

Augmentor/Operations.py

@@ -1948,6 +1948,68 @@ def do(image):
         return augmented_images
 
 
+class ZoomOut(Operation):
+    """
+    This class is used to shrink entire image then return a black-framed
+     image which has the same size as the original image.
+     zoomout effect 
+    """
+
+    def __init__(self, probability, min_factor, max_factor):
+        """
+        The amount of zoom applied is randomised, from between
+        :attr:`min_factor` and :attr:`max_factor`. Set these both to the same
+        value to always zoom by a constant factor.
+
+        :param probability: Controls the probability that the operation is
+         performed when it is invoked in the pipeline.
+        :param min_factor: The minimum amount of zoom to apply. Set both the
+         :attr:`min_factor` and :attr:`min_factor` to the same values to zoom
+         by a constant factor.
+        :param max_factor: The maximum amount of zoom to apply. Set both the
+         :attr:`min_factor` and :attr:`min_factor` to the same values to zoom
+         by a constant factor.
+        :type probability: Float
+        :type min_factor: Float
+        :type max_factor: Float
+        """
+        Operation.__init__(self, probability)
+        self.min_factor = min_factor
+        self.max_factor = max_factor
+
+    def perform_operation(self, images):
+        """
+        Zooms/scales the passed image(s) and returns the new image.
+
+        :param images: The image(s) to be zoomed.
+        :type images: List containing PIL.Image object(s).
+        :return: The transformed image(s) as a list of object(s) of type
+         PIL.Image.
+        """
+        factor = 1 / round(random.uniform(self.min_factor, self.max_factor), 2)
+
+        def do(image):
+            w, h = image.size
+            w_zoom = int(round(image.size[0] * factor))
+            h_zoom = int(round(image.size[1] * factor))
+
+            new_im = Image.new("RGB", (w, h)) 
+            image_zoomed = image.resize((w_zoom, h_zoom), resample=Image.BICUBIC)
+
+            # where to paste the shrinked image into black
+            paste_pose_x = int((w - w_zoom)/2)
+            paste_pose_y = int((h - h_zoom)/2)
+            new_im.paste(image_zoomed, (paste_pose_x, paste_pose_y)) 
+            
+            return new_im
+
+        augmented_images = []
+
+        for image in images:
+            augmented_images.append(do(image))
+
+        return augmented_images
+
 class HSVShifting(Operation):
     """
     CURRENTLY NOT IMPLEMENTED.

Augmentor/Pipeline.py

@@ -237,7 +237,7 @@ def _execute(self, augmentor_image, save_to_disk=True, multi_threaded=True):
 
         if save_to_disk:
             filename, ext = os.path.splitext(os.path.basename(augmentor_image.image_path))
-            file_name = "{}_{}.{}".format(filename, str(uuid.uuid4()), self.save_format)
+            file_name = "{}_{}".format(filename, str(uuid.uuid4()).replace("-", ""))
             try:
                 for i in range(len(images)):
                     if i == 0:
@@ -248,7 +248,7 @@ def _execute(self, augmentor_image, save_to_disk=True, multi_threaded=True):
                                     + file_name \
                                     + "." \
                                     + (self.save_format if self.save_format else augmentor_image.file_format)
-
+                        save_name = "{}.{}".format(file_name, self.save_format)
                         images[i].save(os.path.join(augmentor_image.output_directory, save_name))
 
                     else:
@@ -262,7 +262,7 @@ def _execute(self, augmentor_image, save_to_disk=True, multi_threaded=True):
                                     + file_name \
                                     + "." \
                                     + (self.save_format if self.save_format else augmentor_image.file_format)
-
+                        save_name = "{}_gt.{}".format(file_name, self.save_format)
                         images[i].save(os.path.join(augmentor_image.output_directory, save_name))
 
             except IOError as e:
@@ -1191,6 +1191,36 @@ def zoom(self, probability, min_factor, max_factor):
         else:
             self.add_operation(Zoom(probability=probability, min_factor=min_factor, max_factor=max_factor))
 
+    def zoomout(self, probability, min_factor, max_factor):
+        """
+        Zoom in to an image, while **maintaining its size**. The amount by
+        which the image is zoomed is a randomly chosen value between
+        :attr:`min_factor` and :attr:`max_factor`.
+
+        Typical values may be ``min_factor=1.1`` and ``max_factor=1.5``.
+
+        To zoom by a constant amount, set :attr:`min_factor` and
+        :attr:`max_factor` to the same value.
+
+        .. seealso:: See :func:`zoom_random` for zooming into random areas
+         of the image.
+
+        :param probability: A value between 0 and 1 representing the
+         probability that the operation should be performed.
+        :param min_factor: The minimum factor by which to zoom the image.
+        :param max_factor: The maximum factor by which to zoom the image.
+        :type probability: Float
+        :type min_factor: Float
+        :type max_factor: Float
+        :return: None
+        """
+        if not 0 < probability <= 1:
+            raise ValueError(Pipeline._probability_error_text)
+        elif (min_factor <= 1) or (max_factor <=1):
+            raise ValueError("The min_factor or max_factor argument must be greater than 1.")
+        else:
+            self.add_operation(ZoomOut(probability=probability, min_factor=min_factor, max_factor=max_factor))
+
     def zoom_random(self, probability, percentage_area, randomise_percentage_area=False):
         """
         Zooms into an image at a random location within the image.