yta-image-base 0.0.1__py3-none-any.whl

yta_image_base/__init__.py

@@ -0,0 +1,309 @@
+"""
+Welcome to Youtube Autonomous Image Base module.
+
+TODO: Try to apply the same 'with_' and 'apply_'
+logic that in the 'yta_audio_editor' project to
+keep the original image as it was or to transform
+it in the instance.
+"""
+from yta_image_base.parser import ImageParser
+from yta_image_base.converter import ImageConverter
+from yta_image_base.size import ImageResizer
+from yta_image_base.background import ImageBackgroundRemover
+from yta_image_base.region.finder import ImageRegionFinder
+# TODO: This 'ImageEditor' maybe should be not
+# a class but methods inside the 'Image' class
+from yta_image_base.edition.editor import ImageEditor
+# TODO: This filters below should be in the
+# filters module
+from yta_image.edition.filter import ImageFilter
+from yta_image.edition.filter.motion_blur import MotionBlurDirection
+# TODO: This descriptor below should be in the
+# advanced or AI module
+from yta_image.description.descriptor import DefaultImageDescriptor
+from PIL import Image as PillowImage
+from typing import Union
+
+
+class _Filter:
+    """
+    Class to simplify the access to our filters 
+    for our custom Image class. This class must
+    be used in our custom Image class.
+    """
+
+    image: any
+    """
+    Instance of our custom Image class to simplify
+    the way we applicate filters.
+    """
+
+    def __init__(
+        self,
+        image: 'Image'
+    ):
+        # TODO: Maybe receive the Pillow image instead (?)
+        self.image = image.image
+
+    # TODO: Move this method to the 'advanced' or
+    # 'filters' module
+    def pixelate(
+        self,
+        pixel_size: int,
+        output_filename: Union[str, None] = None
+    ):
+        return ImageFilter.pixelate(self.image, pixel_size, output_filename)
+
+    # TODO: Move this method to the 'advanced' or
+    # 'filters' module
+    def motion_blur(
+        self,
+        kernel_size: int = 30,
+        direction: MotionBlurDirection = MotionBlurDirection.HORIZONTAL,
+        output_filename: Union[str, None] = None
+    ):
+        return ImageFilter.motion_blur(self.image, kernel_size, direction, output_filename)
+    
+# TODO: Move this to the 'advanced' or 
+# 'filters' module
+class _Transform:
+    """
+    Class to simplify the access to our image
+    transformations for our custom Image class.
+    This class must be used in our custom Image
+    class.
+    """
+
+    image: any
+    """
+    Instance of our custom Image class to simplify
+    the way we applicate transformations.
+    """
+
+    def __init__(
+        self,
+        image: 'Image'
+    ):
+        # TODO: Maybe receive the Pillow image instead (?)
+        self.image = image.image
+
+    def to_gameboy(
+        self,
+        output_filename: Union[str, None] = None
+    ):
+        return ImageFilter.to_gameboy(self.image, output_filename)
+    
+    def to_sticker(
+        self,
+        output_filename: Union[str, None] = None
+    ):
+        return ImageFilter.to_sticker(self.image, output_filename)
+
+class _Color:
+    """
+    Class to simplify the access to our image
+    color changes for our custom Image class.
+    This class must be used in our custom Image
+    class.
+    """
+
+    image: any
+    """
+    Instance of our custom Image class to simplify
+    the way we applicate color changes.
+    """
+
+    def __init__(
+        self,
+        image: 'Image'
+    ):
+        # TODO: Maybe receive the Pillow image instead (?)
+        self.image = image.image
+
+    # TODO: Talk about limits (yta_image\edition\settings.py)
+    def set_temperature(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_color_temperature(self.image, factor)
+
+    def set_contrast(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_contrast(self.image, factor)
+    
+    def set_brightness(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_brightness(self.image, factor)
+    
+    def set_sharpness(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_sharpness(self.image, factor)
+
+    def set_white_balance(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_white_balance(self.image, factor)
+    
+    def set_color_hue(
+        self,
+        factor: int = 0
+    ):
+        return ImageEditor.modify_color_hue(self.image, factor)
+
+class Image:
+    """
+    Class to wrap images and make easier the way we
+    work with them.
+    """
+
+    image: PillowImage.Image
+    """
+    The image but stored as a Pillow image.
+    """
+    # TODO: Rethink this variable and move to the
+    # 'advanced' or 'filters' module
+    filter: _Filter
+    """
+    A shortcut to the available filters. The filters,
+    once they are applied, return a new image. The
+    original image remains unchanged.
+    """
+    # TODO: Rethink this variable and move to the
+    # 'advanced' or 'filters' module
+    transform: _Transform
+    """
+    A shortcut to the available transformations. The
+    transformations, once they are applied, return a
+    new image. The original image remains unchanged.
+    """
+    color: _Color
+    """
+    A shortcut to the available color changes. The
+    color changes, once they are applied, return a new
+    image. The original image remains unchanged.
+    """
+    # TODO: Rethink this variable and move to the
+    # 'advanced' or 'filters' module
+    _description: str
+    """
+    A description of the image, given by an engine that
+    has been trained to describe images.
+    """
+    _green_regions: any
+    """
+    The green regions that have been found in the image.
+    """
+    _alpha_regions: any
+    """
+    The alpha (transparent) regions that have been found
+    in the image.
+    """
+
+    @property
+    def as_pillow(
+        self
+    ) -> PillowImage.Image:
+        return self.image
+    
+    @property
+    def as_numpy(
+        self
+    ) -> 'np.ndarray':
+        return ImageConverter.pil_image_to_numpy(self.image)
+    
+    @property
+    def as_opencv(
+        self
+    ) -> 'np.ndarray':
+        return ImageConverter.pil_image_to_opencv(self.image)
+    
+    @property
+    def as_base64(
+        self
+    ) -> str:
+        return ImageConverter.pil_image_to_base64(self.image)
+    
+    # TODO: Add other libraries to be able to transform
+    # TODO: Move this method to the 'advanced' module
+    @property
+    def description(
+        self
+    ) -> str:
+        """
+        A description of the image, given by an engine that
+        has been trained to describe images.
+        """
+        if not hasattr(self, '_description'):
+            self._description = DefaultImageDescriptor().describe(self.image)
+
+        return self._description
+    
+    @property
+    def green_regions(
+        self
+    ):
+        """
+        The green regions that have been found in the image.
+        """
+        if not hasattr(self, '_green_regions'):
+            self._green_regions = ImageRegionFinder.find_green_regions(self.image)
+
+        return self._green_regions
+    
+    @property
+    def alpha_regions(
+        self
+    ):
+        """
+        The alpha (transparent) regions that have been found
+        in the image.
+        """
+        if not hasattr(self, '_alpha_regions'):
+            self._alpha_regions = ImageRegionFinder.find_transparent_regions(self.image)
+
+        return self._alpha_regions
+
+    def __init__(
+        self,
+        image: Union[
+            str,
+            'np.ndarray',
+            PillowImage.Image
+        ]
+    ):
+        self.image = ImageParser.to_pillow(image)
+        self.filter = _Filter(self)
+        self.transform = _Transform(self)
+        self.color = _Color(self)
+
+    def resize(
+        self,
+        size: tuple,
+        output_filename: Union[str, None] = None
+    ):
+        """
+        This method returns the image modified but
+        does not modify the original image.
+        """
+        return ImageResizer.resize(self.image, size, output_filename).file_converted
+    
+    def remove_background(
+        self,
+        output_filename: Union[str, None] = None
+    ):
+        return ImageBackgroundRemover.remove_background(self.image, output_filename).file_converted
+
+# TODO: Maybe I want to update the self.image when
+# I modify something so I return a new Image
+# instance with that modified image, so if you do
+# image = image.filters.pixelate(10) you will update
+# your image instance, but if you do
+# n_image = image.filters.pixelate(10) you will get
+# a new instance in n_image

yta_image_base/background.py

@@ -0,0 +1,91 @@
+from yta_image.parser import ImageParser
+from yta_temp import Temp
+from yta_validation import PythonValidator
+# TODO: I should avoid using this FileReturn
+from yta_general_utils.dataclasses import FileReturn
+from yta_programming.output import Output
+from yta_constants.file import FileType
+from PIL import Image
+from typing import Union
+from subprocess import run
+
+import numpy as np
+
+
+class ImageBackgroundRemover:
+    """
+    Class to remove backgrounds from images.
+    """
+
+    @staticmethod
+    def remove_background(
+        image: Union[str, Image.Image, np.ndarray],
+        output_filename: Union[str, None] = None
+    ) -> FileReturn:
+        """
+        Remove the background of the provided 'image'. This
+        method returns the image as a pillow image in the
+        first element, and the created image filename as the
+        second element.
+        """
+        image_filename = image
+
+        # If provided image is not a file, we store it
+        # to be able to handle
+        if not PythonValidator.is_string(image):
+            image_filename = Temp.get_wip_filename('background_to_remove.png')
+            ImageParser.to_pillow(image).save(image_filename)
+
+        output_filename = Output.get_filename(output_filename, FileType.IMAGE)
+
+        run([
+            'backgroundremover',
+            '-i',
+            image_filename,
+            '-o',
+            output_filename
+        ])
+
+        return FileReturn(
+            ImageParser.to_pillow(output_filename),
+            output_filename
+        )
+    
+    """
+    # Problem with Circular import
+    from backgroundremover.bg import remove as remove_background
+    r = lambda image_filename: image_filename.buffer.read() if hasattr(image_filename, "buffer") else image_filename.read()
+    w = lambda o, data: o.buffer.write(data) if hasattr(o, "buffer") else o.write(data)
+
+    # These below are default values
+    x = remove_background(
+        r(image_filename),
+        model_name = 'u2net',
+        alpha_matting = False,
+        alpha_matting_foreground_threshold = 240,
+        alpha_matting_background_threshold = 10,
+        alpha_matting_erode_structure_size = 10,
+        alpha_matting_base_size = 1000
+    )
+    w(output_filename, x)
+    """
+
+    # TODO: This below seems to work (as shown in this 
+    # commit https://github.com/nadermx/backgroundremover/commit/c590858de4c7e75805af9b8ecdd22baf03a1368f)
+    """
+    from backgroundremover.bg import remove
+    def remove_bg(src_img_path, out_img_path):
+        model_choices = ["u2net", "u2net_human_seg", "u2netp"]
+        f = open(src_img_path, "rb")
+        data = f.read()
+        img = remove(data, model_name=model_choices[0],
+                    alpha_matting=True,
+                    alpha_matting_foreground_threshold=240,
+                    alpha_matting_background_threshold=10,
+                    alpha_matting_erode_structure_size=10,
+                    alpha_matting_base_size=1000)
+        f.close()
+        f = open(out_img_path, "wb")
+        f.write(img)
+        f.close()
+    """

yta_image_base/color/picker.py

@@ -0,0 +1,201 @@
+from yta_image_base.parser import ImageParser
+from collections import Counter
+from PIL import Image
+from typing import Union
+
+import numpy as np
+
+
+# TODO: Maybe move this to another place
+# TODO: Refactor to check if 'pixel' attribute
+# has a len of 3 (rgb) or 4 (rgba) values.
+class PixelFilterFunction:
+    """
+    Class to interact with image pixels and detect greens or transparent
+    pixels to be used in, for example, ImageRegionFinder functionality.
+    """
+
+    @staticmethod
+    def is_green(
+        pixel: list[int, int, int]
+    ):
+        """
+        Check if the provided 'pixel' is a blue pixel,
+        which means that color is in the [100, 255] range
+        while the others are in the [0, 100] range.
+        """
+        # TODO: Validate 'pixel' parameter
+        r, g, b = pixel
+
+        return (
+            0 <= r <= 100 and
+            100 <= g <= 255 and
+            0 <= b <= 100
+        )
+    
+    @staticmethod
+    def is_blue(
+        pixel: list[int, int, int]
+    ):
+        """
+        Check if the provided 'pixel' is a blue pixel,
+        which means that color is in the [100, 255] range
+        while the others are in the [0, 100] range.
+        """
+        # TODO: Validate 'pixel' parameter
+        r, g, b = pixel
+
+        return (
+            0 <= r <= 100 and
+            0 <= g <= 100 and
+            100 <= b <= 255
+        )
+    
+    @staticmethod
+    def is_red(
+        pixel: list[int, int, int]
+    ):
+        """
+        Check if the provided 'pixel' is a blue pixel,
+        which means that color is in the [100, 255] range
+        while the others are in the [0, 100] range.
+        """
+        # TODO: Validate 'pixel' parameter
+        r, g, b = pixel
+
+        return (
+            100 <= r <= 255 and
+            0 <= g <= 100 and
+            0 <= b <= 100
+        )
+    
+    @staticmethod
+    def is_transparent(
+        pixel: list[int, int, int, int]
+    ):
+        """
+        Checks if the alpha channel (4th in array) is set
+        to 0 (transparent). The pixel must be obtained from
+        a RGBA image (so 4 dimentions available).
+        """
+        # TODO: Validate 'pixel' parameter
+        _, _, _, a = pixel
+
+        return a == 0
+
+class ColorPicker:
+    """
+    Class to encapsulate and simplify the functionality related to
+    image color detection.
+    """
+
+    @staticmethod
+    def get_most_common_green_rgb_color(
+        image: Union[str, Image.Image, np.ndarray]
+    ):
+        """
+        Returns the most common (dominant) rgb color in a 
+        (r, g, b) format.
+        """
+        image = ImageParser.to_pillow(image)
+
+        return ColorPicker.get_dominant_color(image, PixelFilterFunction.is_green)
+
+    @staticmethod
+    def get_most_common_green_rgb_color_and_similars(
+        image: Union[str, Image.Image, np.ndarray]
+    ):
+        """
+        Returns the most common rgb color and its similar colors
+        found in the provided 'image_filename' as a pair of values
+        (most_common, similars). Extract them as a pair.
+        """
+        image = ImageParser.to_pillow(image)
+
+        return ColorPicker.get_dominant_and_similar_colors(image, PixelFilterFunction.is_green, _is_similar_green)
+
+    @staticmethod
+    def get_dominant_color(
+        image: Union[str, Image.Image, np.ndarray],
+        pixel_filter_function: PixelFilterFunction = None
+    ):
+        """
+        Opens the provided 'image_filename' and gets the dominant
+        color applying the 'pixel_filter_function' if provided.
+        """
+        image = ImageParser.to_pillow(image)
+
+        return _get_dominant_color(image, pixel_filter_function)[0]
+
+    @staticmethod
+    def get_dominant_and_similar_colors(
+        image: Union[str, Image.Image, np.ndarray],
+        pixel_filter_function: PixelFilterFunction = None,
+        similarity_function = None
+    ):
+        """
+        Opens the provided 'image_filename', gets the dominant
+        color and also the similar ones by applying the 
+        'pixel_filter_function' if provided.
+        """
+        image = ImageParser.to_pillow(image)
+
+        return _get_dominant_color(image, pixel_filter_function, similarity_function)
+
+
+
+def _is_similar_green(
+    color1,
+    color2,
+    tolerance: float = 30
+):
+    tolerance = (
+        30
+        if not tolerance else
+        tolerance
+    )
+
+    # TODO: This below should be comparing 
+    return (
+        abs(color1[0] - color2[0]) <= tolerance * 0.5 and
+        abs(color1[1] - color2[1]) <= tolerance * 2 and
+        abs(color1[2] - color2[2]) <= tolerance * 0.5
+    )
+
+def _get_dominant_color(
+    image: Union[str, Image.Image, np.ndarray],
+    pixel_filter_function: PixelFilterFunction = None,
+    similarity_function = None
+):
+    image = ImageParser.to_pillow(image)
+    
+    pixels = list(image.getdata())
+    if pixel_filter_function is not None:
+        pixels = [
+            pixel
+            for pixel in pixels
+            if pixel_filter_function(pixel)
+        ]
+
+    color_count = Counter(pixels)
+
+    if not color_count:
+        return None, None
+
+    dominant_color = color_count.most_common(1)[0][0] #[0][1] is the 'times'
+
+    if similarity_function is None:
+        return dominant_color, None
+
+    similar_colors = [
+        color
+        for color in color_count.keys()
+        if (
+            similarity_function(color, dominant_color, 30) and
+            color != dominant_color
+        )
+    ]
+    
+    return dominant_color, similar_colors
+
+# TODO: Maybe make this methods work with numpy arrays (?)