calango 2.2.7__tar.gz → 2.2.9__tar.gz

{calango-2.2.7 → calango-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: calango
-Version: 2.2.7
+Version: 2.2.9
 Summary: It looks like calango
 Home-page: https://github.com/cereja-project/calango
 Author: Joab Leite
@@ -15,6 +15,17 @@ Requires-Dist: cereja
 Requires-Dist: opencv-python
 Requires-Dist: matplotlib
 Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Calango Project
 

{calango-2.2.7 → calango-2.2.9}/calango/__init__.py

@@ -26,5 +26,7 @@ from . import settings
 from .devices import Mouse
 from .media import Image, VideoWriter, Video
 
-VERSION = "2.2.7.final.0"
+
+VERSION = "2.2.9.final.0"
+
 __version__ = get_version_pep440_compliant(VERSION)

{calango-2.2.7 → calango-2.2.9}/calango/media.py

@@ -6,13 +6,14 @@ import subprocess
 import threading
 import time
 from abc import abstractmethod
-from typing import Union, Tuple, Sequence, Iterator
+from typing import Union, Tuple, Sequence, Iterator, List
 from urllib.parse import urlparse
 import cereja as cj
 import cv2
 import numpy as np
 import logging
 from matplotlib import pyplot as plt
+from sklearn.cluster import KMeans
 
 from .devices import Mouse
 from .settings import ON_COLAB_JUPYTER
@@ -33,6 +34,14 @@ def is_url(val):
 class Image(np.ndarray):
     _GRAY_SCALE = 'GRAY_SCALE'
     _color_mode = 'BGR'
+    COLORS_RANGE = {
+        'red':     (np.array([0, 0, 100]), np.array([80, 80, 255])),
+        'green':   (np.array([0, 100, 0]), np.array([80, 255, 80])),
+        'blue':    (np.array([100, 0, 0]), np.array([255, 80, 80])),
+        'yellow':  (np.array([0, 100, 100]), np.array([80, 255, 255])),
+        'cyan':    (np.array([100, 100, 0]), np.array([255, 255, 80])),
+        'magenta': (np.array([100, 0, 100]), np.array([255, 80, 255])),
+    }
 
     def __new__(cls, im: Union[str, np.ndarray] = None, color_mode: str = 'BGR', shape=None, dtype=None,
                 **kwargs) -> 'Image':
@@ -99,6 +108,129 @@ class Image(np.ndarray):
     def set_border(self, size: int = 1, color: Tuple[int, int, int] = (0, 255, 0)):
         cv2.rectangle(self, (size, size), (self.width - 1, self.height - 1), color, size)
 
+    def color_range(self, color: str):
+        assert color in self.COLORS_RANGE, f'Color {color} is not valid.'
+        return self.COLORS_RANGE[color]
+
+    def get_color_mask(self, lower, upper):
+        return cv2.inRange(self, lower, upper)
+
+    @staticmethod
+    def calculate_color_percentage(img, lower_bgr, upper_bgr):
+
+        # Create a mask with the pixels that fall within the color range
+        color_mask = cv2.inRange(img, lower_bgr, upper_bgr)
+
+        # Count the number of pixels in the color range
+        color_pixel_count = np.count_nonzero(color_mask)
+
+        # Count the total number of pixels in the image
+        total_pixels = img.shape[0] * img.shape[1]
+
+        # Calculate the percentage of the color
+        color_percentage = (color_pixel_count / total_pixels) * 100
+        return color_percentage
+
+    def get_strides(self, kernel_size, strides=1):
+        """
+        Returns batches of fixed window size (kernel_size) with a given stride
+        @param kernel_size: window size
+        @param strides: default is 1
+        """
+        for i in range(0, self.shape[0] - kernel_size + 1, strides):
+            for j in range(0, self.shape[1] - kernel_size + 1, strides):
+                yield self[i:i + kernel_size, j:j + kernel_size]
+
+    @property
+    def blue_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('blue'))
+
+    @property
+    def green_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('green'))
+
+    @property
+    def red_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('red'))
+
+    @property
+    def yellow_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('yellow'))
+
+    @property
+    def cyan_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('cyan'))
+
+    @property
+    def magenta_percentage(self):
+        return self.calculate_color_percentage(self, *self.color_range('magenta'))
+
+    def hex_to_bgr(self, hex_color):
+        return tuple(int(hex_color[i:i + 2], 16) for i in (0, 2, 4))
+
+    def bgr_to_hex(self, bgr_color):
+        return '%02x%02x%02x' % bgr_color
+
+    def parse_color(self, color):
+        if isinstance(color, str):
+            if color.startswith('#'):
+                return self.hex_to_bgr(color[1:])
+            return self.hex_to_bgr(color)
+        return color
+
+    def get_color_percentage(self, min_color, max_color):
+        return self.calculate_color_percentage(self, self.parse_color(min_color), self.parse_color(max_color))
+
+    def similarity(self, image: Image, method=cv2.TM_CCOEFF_NORMED):
+        result = cv2.matchTemplate(self, image, method)
+        _, max_val, _, max_loc = cv2.minMaxLoc(result)
+        return max_val
+
+    def _padding_points(self, points, distance: 0):
+        if not len(points):
+            return []
+        points = cj.geolinear.find_best_locations(points, distance)
+        return points
+
+    def _match_template(self, template: np.ndarray, method=cv2.TM_CCOEFF_NORMED, threshold=None, all_locations=False,
+                        distance_between_points=1):
+        threshold = threshold or 0.0
+        result = []
+        res = cv2.matchTemplate(self, template, method)
+        if all_locations:
+            loc = np.where(res >= threshold)
+            for n, pt in enumerate(zip(*loc[::-1])):
+                acc = res[pt[1], pt[0]]
+                result.append([int(pt[0] + template.shape[1] // 2), int(pt[1] + template.shape[0] // 2), acc])
+        else:
+            _, max_val, _, max_loc = cv2.minMaxLoc(res)
+            if max_val >= threshold:
+                result.append(
+                        [int(max_loc[0] + template.shape[1] // 2), int(max_loc[1] + template.shape[0] // 2), max_val])
+
+        if distance_between_points > 1:
+            result = self._padding_points(result, distance_between_points)
+        return result
+
+    def match_template(self, template: Union[np.ndarray, List[np.ndarray]], method=cv2.TM_CCOEFF_NORMED,
+                       threshold=None, all_locations=False, distance_between_points=1):
+        threshold = threshold or 0.0
+
+        result = []
+        if not isinstance(template, list):
+            template = [template]
+        for template in template:
+            res = self._match_template(template, method, threshold, all_locations=all_locations,
+                                       distance_between_points=distance_between_points)
+            result.extend(res)
+        return result
+
+    def find_locations_by_color(self, color, distance_between_points=1):
+
+        mask = self.get_color_mask(*self.color_range(color))
+        positions = np.where(mask == 255)[::-1]
+        return self._padding_points(list(zip(*positions)), distance_between_points)
+
     @property
     def mask(self):
         return Image(np.zeros(self.shape[:2], dtype=np.uint8))
@@ -295,6 +427,14 @@ class Image(np.ndarray):
                                  180: cv2.ROTATE_180
                                  }.get(degrees))
 
+    def put_on_center(self, img):
+        img = Image(img)
+        x, y = self.center_position
+        x1 = x - img.width // 2
+        y1 = y - img.height // 2
+        self[y1:y1 + img.height, x1: x1 + img.width] = img
+        return self
+
     def crop_by_center(self, size=None, keep_scale=False) -> Image:
         assert size is None or isinstance(size, (list, tuple)) and cj.is_numeric_sequence(size) and len(
                 size) == 2, 'Send HxW image cropped output'
@@ -345,6 +485,10 @@ class Image(np.ndarray):
         cv2.circle(self, position, radius, color, thickness)
         return self
 
+    def rect(self, start, end, color=(0, 0, 0), thickness=1):
+        cv2.rectangle(self, start, end, color, thickness)
+        return self
+
     def get_mask_circle(self, radius=None, position=None):
         return self.mask.circle(radius=radius, position=position, color=(255, 255, 255), thickness=-1)
 
@@ -377,7 +521,43 @@ class Image(np.ndarray):
     def save(self, p: str):
         cv2.imwrite(p, self)
         assert cj.Path(p).exists, f'Error saving image {p}'
+    def get_background_foreground_colors(self, k=2):
+        """
+        Função para determinar as cores RGB do background e do foreground em uma imagem.
+
+        Parâmetros:
+            image (np.array): imagem em formato de array numpy.
+            k (int): número de clusters para segmentação de cores (2 significa fundo e primeiro plano).
+
+        Retorna:
+            dict: dicionário com as cores RGB do background e do foreground.
+        """
+
+        # Redimensiona a imagem para acelerar o processamento
+        resize_dim = (300, 300)
+        image_resized = cv2.resize(self, resize_dim)
+        image_rgb = cv2.cvtColor(image_resized, cv2.COLOR_BGR2RGB)
+
+        # Converte a imagem para um array de pixels
+        pixels = image_rgb.reshape(-1, 3)
+
+        # Aplica KMeans para segmentar em duas cores (background e foreground)
+        kmeans = KMeans(n_clusters=k, random_state=0)
+        kmeans.fit(pixels)
+
+        # Obtém as cores dos clusters
+        cluster_colors = kmeans.cluster_centers_
+        cluster_labels, counts = np.unique(kmeans.labels_, return_counts=True)
+
+        # Identifica o background como a cor com mais pixels
+        background_idx = cluster_labels[np.argmax(counts)]
+        foreground_idx = cluster_labels[np.argmin(counts)]
+
+        # Converte as cores para inteiros RGB
+        background_rgb = tuple(map(int, cluster_colors[background_idx]))
+        foreground_rgb = tuple(map(int, cluster_colors[foreground_idx]))
 
+        return {"background_rgb": background_rgb, "foreground_rgb": foreground_rgb}
     def plot_colors_histogram(self):
         # tuple to select colors of each channel line
         colors = ("red", "green", "blue") if self._color_mode == 'RGB' else ('blue', 'green', 'red')
@@ -504,6 +684,24 @@ class Image(np.ndarray):
         dir_path = cj.Path(dir_path)
         return [cls(im_p.path) for im_p in dir_path.list_files(ext=ext)]
 
+    @classmethod
+    def _get_image_from_window(cls):
+        with cj.TempDir() as tmp:
+            while True:
+                window = yield
+                p = tmp.path.join('frame.bmp')
+                window.capture_image_bmp(p.path)
+                yield Image(p.path)
+
+    @classmethod
+    def from_window(cls, window: cj.Window) -> 'Image':
+        """
+        Get image from window
+        """
+        gen = cls._get_image_from_window()
+        next(gen)
+        return gen.send(window)
+
 
 class VideoWriter:
     def __init__(self, p, fourcc=None, width=None, height=None, fps=30):
@@ -814,6 +1012,63 @@ class Screen(_IVideo):
         self._capture = False
 
 
+class WindowStream(_IVideo):
+
+    def __init__(self, window: cj.Window, *args, fps=None, **kwargs):
+        self._window = window
+        self._fps = fps or 30
+        self._total_frames = -1
+        self._capture = True
+        self._frames = self.__get_frame()
+        self._width, self._height = self._window.size
+
+    def set_fps(self, fps: Union[int, float]) -> None:
+        assert isinstance(fps, (int, float)), ValueError(f'{fps} value for fps is not valid. Send int or float.')
+        self._fps = fps
+
+    @property
+    def next_frame(self) -> Tuple[bool, Union[np.ndarray, None]]:
+        return True, next(self._frames)
+
+    def __get_frame(self):
+        with cj.TempDir() as tmp:
+            while self._capture:
+                p = tmp.path.join('frame.bmp')
+                self._window.capture_image_bmp(p.path)
+                yield Image(p.path)
+
+    @property
+    def width(self) -> int:
+        return self._window.size[0]
+
+    @property
+    def height(self) -> int:
+        return self._window.size[1]
+
+    @property
+    def total_frames(self) -> int:
+        return self._total_frames
+
+    @property
+    def fps(self) -> Union[int, float]:
+        return self._fps
+
+    @property
+    def is_webcam(self) -> bool:
+        return True
+
+    @property
+    def is_stream(self) -> bool:
+        return False
+
+    @property
+    def is_opened(self) -> bool:
+        return self._capture
+
+    def stop(self):
+        self._capture = False
+
+
 class Video:
 
     def __init__(self, *args, fps=None, frame_preprocess=None, **kwargs):
@@ -833,7 +1088,9 @@ class Video:
 
     def _build(self):
         if len(self._args):
-            if isinstance(self._args[0], str):
+            if isinstance(self._args[0], cj.Window):
+                self._cap = WindowStream(window=self._args[0], *self._args[1:], **self._kwargs)
+            elif isinstance(self._args[0], str):
                 if self._args[0] == 'monitor':
                     self._cap = Screen()
                 elif cj.request.is_url(self._args[0]):

{calango-2.2.7 → calango-2.2.9}/calango.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: calango
-Version: 2.2.7
+Version: 2.2.9
 Summary: It looks like calango
 Home-page: https://github.com/cereja-project/calango
 Author: Joab Leite
@@ -15,6 +15,17 @@ Requires-Dist: cereja
 Requires-Dist: opencv-python
 Requires-Dist: matplotlib
 Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Calango Project
 

{calango-2.2.7 → calango-2.2.9}/calango.egg-info/requires.txt

@@ -2,3 +2,4 @@ cereja
 opencv-python
 matplotlib
 numpy
+scikit-learn