Barrel and Pincushion distortions are added.

augly/image/__init__.py

@@ -13,6 +13,8 @@
     contrast,
     convert_color,
     crop,
+    distort_barrel,
+    distort_pincushion,
     encoding_quality,
     grayscale,
     hflip,
@@ -78,6 +80,7 @@
 from augly.image.transforms import (
     ApplyLambda,
     ApplyPILFilter,
+    DistortBarrel,
     Blur,
     Brightness,
     ChangeAspectRatio,
@@ -101,6 +104,7 @@
     Pad,
     PadSquare,
     PerspectiveTransform,
+    DistortPincushion,
     Pixelization,
     RandomAspectRatio,
     RandomBlur,
@@ -122,6 +126,7 @@
 __all__ = [
     "ApplyLambda",
     "ApplyPILFilter",
+	"DistortBarrel",
     "Blur",
     "Brightness",
     "ChangeAspectRatio",
@@ -147,6 +152,7 @@
     "Pad",
     "PadSquare",
     "PerspectiveTransform",
+    "DistortPincushion",
     "Pixelization",
     "RandomAspectRatio",
     "RandomBlur",
@@ -173,6 +179,8 @@
     "contrast",
     "convert_color",
     "crop",
+    "distort_barrel",
+    "distort_pincushion",
     "encoding_quality",
     "grayscale",
     "hflip",

augly/image/functional.py

@@ -521,6 +521,146 @@ def crop(
     return imutils.ret_and_save_image(aug_image, output_path)
 
 
+def distort_barrel(
+        image: Union[str, Image.Image],
+        output_path: Optional[str] = None,
+        a: float = 0.0,
+        b: float = 0.0,
+        c: float = 0.0,
+        d: float = 1.0,
+        metadata: Optional[List[Dict[str, Any]]] = None,
+):
+    """
+    Applies barrel distortion to the image with the following equation.
+
+    To see effects of the coefficients in detail refer to https://legacy.imagemagick.org/Usage/distorts/#barrel.
+    Below is a direct quotation from the document describing how barrel distortion parameter works.
+
+    >   The values basically form a distortion equation such that...
+
+            Rsrc = r * ( A*r3 + B*r2 + C*r + D )
+
+        Where "r" is the destination radius and "Rsrc" is the source pixel to get the pixel color from. the radii
+        are normalized so that radius = '1.0' for the half minimum width or height of the input image.
+        This may seem reversed but that is because the Reverse Pixel Mapping technique is used to ensure
+        complete coverage of the resulting image.
+
+    Setting A = B = C = 0 and D = 1 results in no change in the input image. Negative values of A, B and C will
+    result in reverse barrel effect closer to pincushion effect.
+
+    @param image: the path to an image or a variable of type PIL.Image.Image
+        to be augmented
+
+    @param output_path: the path in which the resulting image will be stored.
+        If None, the resulting PIL Image will still be returned
+
+    @param a: Coefficient A in the equation Rsrc(r). Larger values results in more barrel effect,
+        has higher effect than b and c.
+
+    @param b: Coefficient B in the equation Rsrc(r). Larger values results in more barrel effect,
+        has lower effect than a and higher effect than c.
+
+    @param c: Coefficient C in the equation Rsrc(r). Larger values results in more barrel effect,
+        has lower effect than a and b.
+
+    @param d: Coefficient D in the equation Rsrc(r). Controls the overall scaling of the image.
+        In a positive domain, values larger than 1 will shrink the image. Negative values would
+        result in both vertically and horizontally flipped image scaled in a mirrored way
+        of positive domain.
+
+    @param metadata: if set to be a list, metadata about the function execution
+        including its name, the source & dest width, height, etc. will be appended
+        to the inputted list. If set to None, no metadata will be appended or returned
+
+    @returns: the augmented PIL Image
+    """
+    image = imutils.validate_and_load_image(image).convert("RGB")
+    func_kwargs = imutils.get_func_kwargs(metadata, locals())
+
+    aug_image = imutils.distort(
+            image=image,
+            method="barrel",
+            distortion_args=(a, b, c, d),
+    )
+
+    imutils.get_metadata(
+        metadata=metadata,
+        function_name="distort_barrel",
+        aug_image=aug_image,
+        **func_kwargs,
+    )
+
+    return imutils.ret_and_save_image(aug_image, output_path)
+
+
+def distort_pincushion(
+        image: Union[str, Image.Image],
+        output_path: Optional[str] = None,
+        a: float = 0.0,
+        b: float = 0.0,
+        c: float = 0.0,
+        d: float = 1.0,
+        metadata: Optional[List[Dict[str, Any]]] = None,
+):
+    """
+    To see effects of the coefficients in detail refer to
+    https://legacy.imagemagick.org/Usage/distorts/#barrelinverse. Below is a direct quotation from the document
+    describing how pincushion (barrel inverse) distortion parameter works.
+
+    >   The 'BarrelInverse' distortion method is very similar to the previous Barrel Distortion distortion method,
+     and in fact takes the same set of arguments. However the formula that is applied is slightly different,
+     with the main part of the equation dividing the radius. that is the Equation has been inverted.
+
+        Rsrc = r / ( A*r3 + B*r2 + C*r + D )
+
+        NOTE: This equation does NOT produce the 'reverse' the 'Barrel' distortion. You can NOT use it to 'undo'
+        the previous distortion.
+
+    @param image: the path to an image or a variable of type PIL.Image.Image
+        to be augmented
+
+    @param output_path: the path in which the resulting image will be stored.
+        If None, the resulting PIL Image will still be returned
+
+    @param a: Coefficient A in the equation Rsrc(r). Larger values results in more pincushion effect,
+        has higher effect than b and c.
+
+    @param b: Coefficient B in the equation Rsrc(r). Larger values results in more pincushion effect,
+        has higher effect than b and c.
+
+    @param c: Coefficient C in the equation Rsrc(r). Larger values results in more pincushion effect,
+        has higher effect than b and c.
+
+    @param d: Coefficient D in the equation Rsrc(r). Controls the overall scaling of the image.
+        In a positive domain, values larger than 1 will enlarge the image (zoomed in). Negative
+        values would result in both vertically and horizontally flipped image scaled in a mirrored way
+        of positive domain.
+
+    @param metadata: if set to be a list, metadata about the function execution
+        including its name, the source & dest width, height, etc. will be appended
+        to the inputted list. If set to None, no metadata will be appended or returned
+
+    @returns: the augmented PIL Image
+    """
+    image = imutils.validate_and_load_image(image).convert("RGB")
+    func_kwargs = imutils.get_func_kwargs(metadata, locals())
+
+    aug_image = imutils.distort(
+            image=image,
+            method="barrel_inverse",
+            distortion_args=(a, b, c, d),
+    )
+
+    imutils.get_metadata(
+        metadata=metadata,
+        function_name="distort_pincushion",
+        aug_image=aug_image,
+        **func_kwargs,
+    )
+
+    return imutils.ret_and_save_image(aug_image, output_path)
+
+
 def encoding_quality(
     image: Union[str, Image.Image],
     output_path: Optional[str] = None,
@@ -2011,3 +2151,10 @@ def vflip(
     imutils.get_metadata(metadata=metadata, function_name="vflip", **func_kwargs)
 
     return imutils.ret_and_save_image(aug_image, output_path)
+
+
+if __name__ == "__main__":
+    aug_img = distort_pincushion(
+            image="/home/devrimcavusoglu/lab/gh/AugLy/augly/assets/tests/image/inputs/dfdc_1.jpg",
+    )
+    aug_img.show()

augly/image/intensity.py

@@ -100,6 +100,20 @@ def crop_intensity(metadata: Dict[str, Any], **kwargs) -> float:
     return resize_intensity_helper(metadata)
 
 
+def distort_barrel_intensity(a: float, b: float, c: float, d: float, **kwargs) -> float:
+    barrel_coefficients_magnitude = abs(a) + abs(b) + abs(c)
+    scale = np.abs(d)
+    intensity = 100 * (barrel_coefficients_magnitude / scale)
+    return float(np.clip(intensity, 0, 100))
+
+
+def distort_pincushion_intensity(a: float, b: float, c: float, d: float, **kwargs) -> float:
+    pincushion_coefficients_magnitude = np.abs([a, b, c]).sum()
+    scale = np.abs(d)
+    intensity = 100 * (pincushion_coefficients_magnitude / scale)
+    return float(np.clip(intensity, 0, 100))
+
+
 def encoding_quality_intensity(quality: int, **kwargs):
     assert (
         isinstance(quality, int) and 0 <= quality <= 100

augly/image/transforms.py

@@ -188,6 +188,76 @@ def apply_transform(
         return F.apply_pil_filter(image, filter_type=self.filter_type, metadata=metadata)
 
 
+class DistortBarrel(BaseTransform):
+    def __init__(self, a: float = 0.0, b: float = 0.0, c: float = 0.0, d: float = 1.0, p: float = 1):
+        """
+        @param a: Coefficient A in the equation Rsrc(r).
+
+        @param b: Coefficient B in the equation Rsrc(r).
+
+        @param c: Coefficient C in the equation Rsrc(r).
+
+        @param d: Coefficient D in the equation Rsrc(r).
+
+        @param p: the probability of the transform being applied; default value is 1.0
+        """
+        super().__init__(p)
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+
+    def apply_transform(self, image: Image.Image, metadata: Optional[List[Dict[str, Any]]] = None) -> Image.Image:
+        """
+        Applies barrel distortion to the image.
+
+        @param image: PIL Image to be augmented
+
+        @param metadata: if set to be a list, metadata about the function execution
+                including its name, the source & dest width, height, etc. will be appended to
+                the inputted list. If set to None, no metadata will be appended or returned
+
+        @returns: Augmented PIL Image
+        """
+        return F.distort_barrel(image, a=self.a, b=self.b, c=self.c, d=self.d, metadata=metadata)
+
+
+class DistortPincushion(BaseTransform):
+    def __init__(self, a: float = 0.0, b: float = 0.0, c: float = 0.0, d: float = 1.0, p: float = 1):
+        """
+
+
+        @param a: Coefficient A in the equation Rsrc(r).
+
+        @param b: Coefficient B in the equation Rsrc(r).
+
+        @param c: Coefficient C in the equation Rsrc(r).
+
+        @param d: Coefficient D in the equation Rsrc(r).
+
+        @param p: the probability of the transform being applied; default value is 1.0
+        """
+        super().__init__(p)
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+
+    def apply_transform(self, image: Image.Image, metadata: Optional[List[Dict[str, Any]]] = None) -> Image.Image:
+        """
+        Applies pinchusion distortion to the image.
+
+        @param image: PIL Image to be augmented
+
+        @param metadata: if set to be a list, metadata about the function execution
+                including its name, the source & dest width, height, etc. will be appended to
+                the inputted list. If set to None, no metadata will be appended or returned
+
+        @returns: Augmented PIL Image
+        """
+        return F.distort_pincushion(image, a=self.a, b=self.b, c=self.c, d=self.d, metadata=metadata)
+
+
 class Blur(BaseTransform):
     def __init__(self, radius: float = 2.0, p: float = 1.0):
         """

augly/image/utils.py

@@ -11,6 +11,7 @@
 import augly.utils as utils
 import numpy as np
 from PIL import Image
+from wand.image import Image as wImage
 
 JPEG_EXTENSIONS = [".jpg", ".JPG", ".jpeg", ".JPEG"]
 
@@ -279,3 +280,23 @@ def compute_stripe_mask(
     binary_mask = softmax_mask > (math.cos(math.pi * line_width) + 1) / 2
 
     return binary_mask
+
+
+def distort(
+        image: Image.Image,
+        method: str,
+        distortion_args: Tuple,
+) -> Image.Image:
+    """
+    Distorts the image with a specified type of distortion. This function wraps `Wand` package
+    `wand.image.Image.distort()` method to apply distortions. This function is a helper function
+    to apply lens distortions on the image, and it is not meant to be used for methods explicitly
+    written in AugLy. To see full set of distortion methods, see
+    https://docs.wand-py.org/en/0.5.3/wand/image.html#wand.image.DISTORTION_METHODS
+    """
+    image = np.array(image)
+    wimage = wImage.from_array(image)
+    wimage.distort(method, distortion_args)
+    aug_image = Image.fromarray(np.array(wimage))
+
+    return aug_image

augly/tests/image_tests/functional_unit_test.py

@@ -21,6 +21,12 @@ def test_blur(self):
     def test_brightness(self):
         self.evaluate_function(imaugs.brightness)
 
+    def test_distort_barrel(self):
+        self.evaluate_function(imaugs.distort_barrel, a=0.1)
+
+    def test_distort_pincushion(self):
+        self.evaluate_function(imaugs.distort_pincushion, a=0.1)
+
     def test_change_aspect_ratio(self):
         self.evaluate_function(imaugs.change_aspect_ratio)
 

augly/tests/image_tests/transforms_unit_test.py

@@ -23,6 +23,9 @@ def test_ApplyLambda(self):
     def test_ApplyPILFilter(self):
         self.evaluate_class(imaugs.ApplyPILFilter(), fname="apply_pil_filter")
 
+    def test_BarrelDistortion(self):
+        self.evaluate_class(imaugs.DistortBarrel(a=0.1), fname="distort_barrel")
+
     def test_Blur(self):
         self.evaluate_class(imaugs.Blur(), fname="blur")
 
@@ -144,6 +147,9 @@ def test_PerspectiveTransform(self):
             imaugs.PerspectiveTransform(sigma=100.0), fname="perspective_transform"
         )
 
+    def test_PincushionDistortion(self):
+        self.evaluate_class(imaugs.DistortPincushion(a=0.1), fname="distort_pincushion")
+
     def test_Pixelization(self):
         self.evaluate_class(imaugs.Pixelization(), fname="pixelization")