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

yta_image_base/parser.py

@@ -0,0 +1,128 @@
+from yta_image_base.converter import ImageConverter
+from yta_file.handler import FileHandler
+from yta_file.filename.handler import FilenameHandler, FileType
+from yta_validation import PythonValidator
+from PIL import Image
+from typing import Union
+
+import numpy as np
+
+
+class ImageParser:
+    """
+    Class to simplify the way we handle the image parameters
+    so we can parse them as Pillow images, as numpy arrays,
+    etc.
+    """
+
+    @staticmethod
+    def to_pillow(
+        image: Union[str, Image.Image, np.ndarray],
+        mode: str = 'RGB'
+    ) -> Image.Image:
+        """
+        Returns an instance of a Pillow Image.Image of the given
+        'image' if it is a valid image and no error found.
+
+        Result is a Pillow image which is in RGB (or RGBA) format.
+        """
+        # TODO: By now we are only accepting string filenames,
+        # Pillow Image.Image instances and numpy arrays.
+        if image is None:
+            raise Exception('No "image" parameter provided.')
+        
+        if (
+            not PythonValidator.is_string(image) and
+            not PythonValidator.is_numpy_array(image) and
+            not PythonValidator.is_instance(image, Image.Image)
+        ):
+            raise Exception('The "image" parameter provided is not a string nor a Image.Image nor a np.ndarray.')
+
+        mode = (
+            'RGB'
+            if not mode else
+            mode
+        )
+
+        if mode not in ['RGB', 'RGBA']:
+            raise Exception('The provided "mode" parameters is not a valid mode: RGB or RGBA.')
+
+        # We can have problems with np.ndarray
+        if PythonValidator.is_numpy_array(image):
+            image = ImageConverter.numpy_image_to_pil(image)
+        elif PythonValidator.is_string(image):
+            if not FilenameHandler.is_of_type(image, FileType.IMAGE):
+                raise Exception('The "image" parameter provided is not a valid image filename.')
+            
+            if not FileHandler.is_image_file(image):
+                raise Exception('The "image" parameter provided is not a valid image.')
+            
+            image = Image.open(image)
+
+        return image.convert(mode)
+    
+    @staticmethod
+    def to_numpy(
+        image: Union[str, Image.Image, np.ndarray],
+        mode: str = 'RGB'
+    ) -> np.ndarray:
+        """
+        Returns a numpy array representing the given 'image'
+        if it is a valid image and no error found.
+
+        The 'mode' parameter will be used to open the image
+        with Pillow library and then turning into numpy when
+        necessary. Must be 'RGB' or 'RGBA'.
+
+        Result is in RGB or RGBA format.
+        """
+        # TODO: By now we are only accepting string filenames,
+        # Pillow Image.Image instances and numpy arrays.
+        if image is None:
+            raise Exception('No "image" parameter provided.')
+        
+        if not PythonValidator.is_instance(image, [str, Image.Image, np.ndarray]):
+            raise Exception('The "image" parameter provided is not a string nor a Image.Image nor a np.ndarray.')
+        
+        mode = 'RGB' if not mode else mode
+
+        if mode not in ['RGB', 'RGBA']:
+            raise Exception('The provided "mode" parameters is not a valid mode: RGB or RGBA.')
+
+        # We can have problems with np.ndarray
+        if PythonValidator.is_instance(image, Image.Image):
+            image = ImageConverter.pil_image_to_numpy(image.convert(mode))
+        elif PythonValidator.is_string(image):
+            if not FilenameHandler.is_of_type(image, FileType.IMAGE):
+                raise Exception('The "image" parameter provided is not a valid image filename.')
+            
+            if not FileHandler.is_image_file(image):
+                raise Exception('The "image" parameter provided is not a valid image.')
+            
+            image = ImageConverter.pil_image_to_numpy(Image.open(image).convert(mode))
+        elif PythonValidator.is_numpy_array(image):
+            if image.shape[2] == 3 and mode == 'RGBA':
+                # numpy but RGB to RGBA
+                image = np.dstack((image, np.ones((image.shape[0], image.shape[1]), dtype = np.uint8) * 255))
+                # Moviepy uses the alpha channel as 0 or 1, not as 255
+                # but this is only an image parser not a moviepy parser
+                #image = np.dstack((image, np.ones((image.shape[0], image.shape[1]), dtype = np.uint8)))
+            elif image.shape[2] == 4 and mode == 'RGB':
+                # numpy but RGBA to RGB
+                image = image[:, :, :3]
+
+        return image
+    
+    @staticmethod
+    def to_opencv(
+        image: Union[str, Image.Image, np.ndarray],
+        mode: str = 'RGB'
+    ) -> np.ndarray:
+        """
+        The 'image' is read as a RGB numpy array and then
+        transformed into an BGR numpy array because Opencv
+        uses BGR format.
+
+        Result is in BGR format.
+        """
+        return ImageParser.to_numpy(image, mode)[:, :, ::-1]

yta_image_base/region/finder.py

@@ -0,0 +1,248 @@
+from yta_image_base.parser import ImageParser
+from yta_image_base.color.picker import PixelFilterFunction
+from yta_validation.parameter import ParameterValidator
+from yta_general_utils.region import Region
+from typing import Union
+from PIL import Image
+
+import numpy as np
+import cv2
+
+
+MIN_REGION_SIZE = (1920 / 20, 1080 / 20)
+"""
+The minimum size a region must have to be accepted
+as a valid region.
+"""
+
+class ImageRegionFinder:
+
+    DIRECTIONS = [
+        (-1, 0),
+        (1, 0),
+        (0, -1),
+        (0, 1),
+        (-1, -1),
+        (-1, 1),
+        (1, -1),
+        (1, 1)
+    ]
+    """
+    The directions to move while searching, that are
+    the 8 possible options: up, up-right, right, etc.,
+    expressed as (x, y) tuples.
+    """
+
+    @staticmethod
+    def is_valid(
+        position: tuple[int, int],
+        image,
+        visited,
+        filter_func: callable
+    ) -> bool:
+        """
+        This method verifies if the pixel is between the limits
+        and fits the filter and is unvisited.
+        """
+        rows, cols, _ = image.shape
+
+        return (
+            0 <= position[0] < rows and
+            0 <= position[1] < cols and
+            not visited[position[0], position[1]] and
+            filter_func(image[position[0], position[1]])
+        )
+
+    @staticmethod
+    def _dfs(
+        image: np.ndarray,
+        visited,
+        x,
+        y,
+        region,
+        filter_func: callable
+    ):
+        """
+        A Deep First Search algorithm applied to the
+        image to obtain all the pixels connected within
+        a region.
+        """
+        if not isinstance(image, np.ndarray):
+            raise Exception('The provided "image" parameter is not a valid np.ndarray.')
+
+        stack = [(x, y)]
+        visited[x, y] = True
+        region.append((x, y))
+        
+        while stack:
+            current_x, current_y = stack.pop()
+            for direction_x, direction_y in ImageRegionFinder.DIRECTIONS:
+                new_x, new_y = current_x + direction_x, current_y + direction_y
+                if ImageRegionFinder.is_valid((new_x, new_y), image, visited, filter_func):
+                    visited[new_x, new_y] = True
+                    region.append((new_x, new_y))
+                    stack.append((new_x, new_y))
+
+    @staticmethod
+    def is_inside(
+        small_bounds,
+        large_bounds
+    ):
+        """
+        This method verifies if the bounds of a found region are
+        inside another bounds to discard the smaller regions.
+        """
+        min_x_small, max_x_small, min_y_small, max_y_small = small_bounds
+        min_x_large, max_x_large, min_y_large, max_y_large = large_bounds
+        
+        return (
+            min_x_small >= min_x_large and max_x_small <= max_x_large and
+            min_y_small >= min_y_large and max_y_small <= max_y_large
+        )
+
+    @staticmethod
+    def find_regions(
+        image: np.ndarray,
+        filter_func: PixelFilterFunction
+    ) -> list[Region]:
+        """
+        This method looks for all the existing regions of transparent
+        pixels that are connected ones to the others (neighbours). The
+        'filter_func' parameter is the one that will classify the pixels
+        as, for example, transparent or green. That 'filter_func' must
+        be a method contained in the PixelFilterFunction class.
+
+        This method returns the found regions as objects with 'top_left'
+        and 'bottom_right' fields that are arrays of [x, y] positions
+        corresponding to the corners of the found regions.
+        """
+        ParameterValidator.validate_mandatory_numpy_array('image', image)
+
+        rows, cols, _ = image.shape
+        visited = np.zeros((rows, cols), dtype=bool)
+        regions = []
+        
+        for row in range(rows):
+            for col in range(cols):
+                # If we find a transparent pixel, we search
+                if filter_func(image[row, col]) and not visited[row, col]:
+                    region = []
+                    ImageRegionFinder._dfs(image, visited, row, col, region, filter_func)
+
+                    # TODO: What is this for? Maybe just a break
+                    # if len(region) = 10 (?)
+                    for i, _ in enumerate(region):
+                        if i == 10:
+                            break
+                    
+                    if region:
+                        min_x = min(px[0] for px in region)
+                        max_x = max(px[0] for px in region)
+                        min_y = min(px[1] for px in region)
+                        max_y = max(px[1] for px in region)
+
+                        # These are the limits of the region, calculated as a
+                        # rectangle that wraps the whole region, but not the
+                        # real region and limits
+                        bounds = (min_x, max_x, min_y, max_y)
+
+                        # We need to avoid small regions contained in others and
+                        # also use a minimum size to accept a region as valid
+                        if (
+                            max_x - min_x >= MIN_REGION_SIZE[0] and
+                            max_y - min_y >= MIN_REGION_SIZE[1] and
+                            not any(
+                                ImageRegionFinder.is_inside(bounds, r['bounds'])
+                                for r in regions
+                            )
+                        ):
+                            regions.append({
+                                'bounds': bounds,
+                                'coordinates': region
+                            })
+
+        # I want another format, so:
+        for index, region in enumerate(regions):
+            regions[index] = Region(region['bounds'][2], region['bounds'][0], region['bounds'][3], region['bounds'][1], region['coordinates'])
+
+        return regions
+    
+    @staticmethod
+    def find_green_regions(
+        image: Union[str, Image.Image, np.ndarray]
+    ) -> list[Region]:
+        """
+        Get the green regions that exist in the provided
+        'image' (if existing), ignoring the ones whose
+        dimensions are below the MIN_REGION_SIZE constant.
+        """
+        image = ImageParser.to_numpy(image, 'RGB')
+            
+        return ImageRegionFinder.find_regions(image, PixelFilterFunction.is_green)
+    
+    @staticmethod
+    def find_transparent_regions(
+        image: Union[str, Image.Image, np.ndarray]
+    ) -> list[Region]:
+        """
+        Get the transparent (alpha) regions that exist in
+        the provided 'image' (if existing), ignoring the
+        ones whose dimensions are below the MIN_REGION_SIZE
+        constant.
+        """
+        image = ImageParser.to_numpy(image, 'RGBA')
+            
+        return ImageRegionFinder.find_regions(image, PixelFilterFunction.is_transparent)
+
+
+
+
+
+
+
+
+
+# TODO: This below need work, is using a HSV mask to
+# recognize regions, but this is actually a new class
+# to bring functionality from 'yta_general_utils'
+
+class RegionFinderTest:
+    
+    @staticmethod
+    def detect_regions(image, low_range, high_range):
+        # Convertir la imagen de BGR a HSV
+        imagen_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Crear una máscara con los píxeles que están dentro del rango de color
+        mascara = cv2.inRange(imagen_hsv, low_range, high_range)
+        
+        # Encontrar los contornos de las regiones detectadas
+        contornos, _ = cv2.findContours(mascara, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Dibujar los contornos sobre la imagen original
+        imagen_contornos = image.copy()
+        for contorno in contornos:
+            if cv2.contourArea(contorno) > 100:  # Filtrar contornos pequeños
+                cv2.drawContours(imagen_contornos, [contorno], -1, (0, 255, 0), 2)
+        
+        return imagen_contornos, mascara
+
+    @staticmethod
+    def test():
+        imagen = cv2.imread('imagen.jpg')
+
+        # Definir el rango de color en HSV (por ejemplo, un verde brillante)
+        rango_bajo = np.array([35, 50, 50])   # El valor mínimo del verde en HSV
+        rango_alto = np.array([85, 255, 255])  # El valor máximo del verde en HSV
+
+        # Llamar a la función para detectar las regiones del color
+        imagen_contornos, mascara = RegionFinderTest.detect_regions(imagen, rango_bajo, rango_alto)
+
+        # Mostrar los resultados
+        cv2.imshow('Regiones Detectadas', imagen_contornos)
+        cv2.imshow('Máscara', mascara)
+
+        # Esperar a que se presione una tecla para cerrar las ventanas
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+

yta_image_base/size.py

@@ -0,0 +1,135 @@
+from yta_image_base.parser import ImageParser
+# TODO: Get this method from other library
+from yta_multimedia.utils.resize import get_cropping_points_to_keep_aspect_ratio
+from yta_constants.file import FileExtension
+from yta_programming.output import Output
+# TODO: I should avoid using this FileReturn
+from yta_general_utils.dataclasses import FileReturn
+from PIL import Image
+from typing import Union
+
+import cv2
+
+
+class ImageResizer:
+    """
+    Class to resize images.
+    """
+
+    @staticmethod
+    def resize(
+        image: Union[str, any],
+        size: tuple[int, int],
+        output_filename: Union[str, None] = None
+    ) -> FileReturn:
+        """
+        Resizes the image to the provided 'size' by cropping a
+        region of the given 'image' that fits the 'size' aspect
+        ratio and resizing that region to the 'size'.
+
+        This method is using the whole image and then resizing,
+        so the quality of the image is preserved and no small
+        regions are used. The most part of the image is 
+        preserved.
+
+        This method returns the image modified.
+
+        This method will write the image if 'output_filename' is
+        provided.
+        """
+        image = ImageParser.to_pillow(image)
+
+        # TODO: Maybe move the method to another library (?)
+        top_left, bottom_right = get_cropping_points_to_keep_aspect_ratio(image.size, size)
+        image = image.crop((top_left[0], top_left[1], bottom_right[0], bottom_right[1]))
+        image = image.resize(size)
+
+        if output_filename is not None:
+            output_filename = Output.get_filename(output_filename, FileExtension.PNG)
+            image.save(output_filename)
+
+        return FileReturn(
+            image,
+            output_filename
+        )
+
+
+
+
+# TODO: This below is so raw... remove if
+# no longer used and replaceable with others
+def resize_scaling(image_filename, width, height, output_filename = None):
+    """
+    Resizes the provided 'image_filename' to the provided 'width' and 'height' keeping the
+    aspect ratio. This method enlarges the image to fit the desired size and then makes a 
+    crop to obtain that size from the center of the resized image. If 'output_filename' is
+    provided, the image is saved locally with that name.
+    """
+    image = Image.open(image_filename)
+    image_width, image_height = image.size
+
+    if image_width == width and image_height == height:
+        return image.save(output_filename)
+
+    aspect_ratio = image_width / image_height
+    if aspect_ratio > (width / height):
+        # Image is very horizontal, so width changes faster, we need to focus on height
+        factor = (height * 100 / image_height) / 100
+        image_width = int(image_width * factor)
+        image_height = height
+    else:
+        # Image is very vertical, so height changes faster, we need to focus on width
+        factor = (width * 100 / image_width) / 100
+        image_width = 1920
+        image_height = int(image_height * factor)
+    image = image.resize((image_width, image_height))
+
+    # We will crop form the center to edges
+    left = 0
+    right = width
+    top = 0
+    bottom = height
+    if image_width > width:
+        # If it is 1960 => leave [0, 20], get [20, 1940], leave [1940, 1960]
+        margin = int((image_width - width) / 2)
+        left = 0 + margin
+        right = image_width - margin
+        # We make and adjustment if some pixel left
+        while (right - left) > width:
+            right -= 1
+        while (right - left) < width:
+            if left > 0:
+                left -= 1
+            else:
+                right += 1
+    if image_height > height:
+        # If it is 1140 => leave [0, 30], get [30, 1110], leave [1110, 1140]
+        margin = int((image_height - height) / 2)
+        top = 0 + margin
+        bottom = image_height - margin
+        # We make and adjustment if some pixel left
+        while (bottom - top) > height:
+            bottom -= 1
+        while (bottom - top) < height:
+            if top > 0:
+                top -= 1
+            else:
+                bottom += 1
+
+    image = image.crop((left, top, right, bottom))
+    # Image that is 1920x1080 and is the center of the original image
+    if output_filename:
+        image.save(output_filename)
+
+    return image
+
+def resize_without_scaling(image_filename, width = 1920, height = 1080):
+    """
+    This method gets an image, resizes it and overwrites the original one.
+
+    TODO: This method need work.
+    """
+    # TODO: We resize it simply, we don't care about scale
+    image = cv2.imread(image_filename)
+    resized_image = cv2.resize(image, dsize = (width, height), interpolation = cv2.INTER_CUBIC)
+    cv2.imwrite(image_filename, resized_image)

yta_image_base-0.0.1.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yta_image_base-0.0.1.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.3
+Name: yta-image-base
+Version: 0.0.1
+Summary: Youtube Autonomous Image Base Module.
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: ==3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Requires-Dist: numpy (>=1.23.5,<2.0.0)
+Requires-Dist: opencv-python (>=4.11.0.86,<5.0.0.0)
+Requires-Dist: pillow (>=9.5.0,<10.0.0)
+Requires-Dist: yta_constants (>=0.0.1,<1.0.0)
+Requires-Dist: yta_file (>=0.0.1,<1.0.0)
+Requires-Dist: yta_programming (>=0.0.1,<1.0.0)
+Requires-Dist: yta_temp (>=0.0.1,<1.0.0)
+Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous Audio Editor Module
+
+The Audio editor module.
+
+Please, check the 'pyproject.toml' file to see the dependencies.

yta_image_base-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+yta_image_base/__init__.py,sha256=adJ0wH4CVSHCXwlvbcl7BMV9Xy8JuEsLgYjBr3uIGug,8715
+yta_image_base/background.py,sha256=8Vbe_fcaKrW2E5w3zf4URN5iUlU4VEjxzh3Gp2bDpSY,3136
+yta_image_base/color/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yta_image_base/color/picker.py,sha256=uPgFQVS4dE36EF_bxJsFxhqe8Z9M1xR_YpDDtU_1mHA,5712
+yta_image_base/converter.py,sha256=83fK4yMarkQ4hEkBMzzvKrozyFfmlUpl6yzspB3YAuY,9222
+yta_image_base/edition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yta_image_base/edition/editor.py,sha256=fRd3qZInOUfPyMbzktc877iqeSVrTZw43f4EhfBwdzE,13477
+yta_image_base/edition/settings.py,sha256=N3NSxlc7NBZbB9R-Uv8GkgJU_TvjNTSgpw5bXF11YDc,577
+yta_image_base/parser.py,sha256=5GGDBxpqyjzM95sGtxaQ259LnCmYxxs1BJtvkhDuMj0,5090
+yta_image_base/region/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yta_image_base/region/finder.py,sha256=-R2EV0sw-74ltEeAbO3VLIjzfWKGWNQdvsVb_ucSI8U,8859
+yta_image_base/size.py,sha256=q_Q26CV_iVsb1yWDfCnDANlJ-zTNR-b1Ac-j8207WGE,4858
+yta_image_base-0.0.1.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_image_base-0.0.1.dist-info/METADATA,sha256=wpac1WKMTa6_Jkz3MOQrWq66QX2CDYISDjgj0h9f0W0,818
+yta_image_base-0.0.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_image_base-0.0.1.dist-info/RECORD,,

yta_image_base-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.1
+Root-Is-Purelib: true
+Tag: py3-none-any