homa 0.24__tar.gz → 0.25__tar.gz

{homa-0.24 → homa-0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: homa
-Version: 0.24
+Version: 0.25
 Maintainer: Taha Shieenavaz
 Maintainer-email: tahashieenavaz@gmail.com
 Description-Content-Type: text/markdown

{homa-0.24 → homa-0.25}/homa/__init__.py

@@ -1,5 +1,4 @@
 from .main import *
-from .filters import *
 from .camera import *
 from .orientation import *
 from .spaces import *
@@ -7,3 +6,6 @@ from .events import *
 from .shapes import *
 
 from .helpers import *
+
+from .classes.Window import Window
+from .classes.Image import Image

{homa-0.24 → homa-0.25}/homa/camera.py

@@ -1,15 +1,18 @@
 import cv2
-from .classes.Repository import Repository
 from typing import Iterator
+from .classes.Repository import Repository
+from .classes.Window import Window
 
 
 def camera(delay: int = 10, exit_on: str = "q") -> Iterator[int]:
+    cameraWindow = Window(640, 480)
+
     pressed_key = None
     capture = cv2.VideoCapture(0)
     frame_number = 0
     while pressed_key != ord(exit_on):
         _, frame = capture.read()
-        Repository.images["camera"] = frame
+        cameraWindow.update(frame)
 
         frame_number += 1
         yield frame_number

homa-0.25/homa/classes/Image.py

@@ -0,0 +1,19 @@
+from .Window import Window
+from ..helpers.string import randomLowercaseString
+import cv2
+
+
+class Image(Window):
+    def __init__(self, filename: str | Window):
+        if isinstance(filename, Window):
+            image = filename.getImage()
+            title = f"{filename.getTitle()} Cloned"
+
+        elif isinstance(filename, str):
+            image = cv2.imread(filename)
+            title = filename
+
+        super().__init__(
+            image=image,
+            title=title
+        )

{homa-0.24 → homa-0.25}/homa/classes/Repository.py

@@ -1,14 +1,16 @@
 from ..helpers.environment import is_colab
+from ..helpers.string import randomLowercaseString
 
 
 class RepositoryWrapper:
     def __init__(self):
-        self.sigmaX = 0
-        self.sigmaY = 0
-
         self.directory = "./"
-        self.images = {}
-        self.windows = {}
+
+        self.settings = {
+            "thickness": 2,
+            "color": (0, 0, 0),
+            "sigma": [0, 0]
+        }
 
         if is_colab():
             from google.colab.patches import cv2_imshow as imshow
@@ -23,5 +25,11 @@ class RepositoryWrapper:
 
         self.imshow = final_imshow
 
+    def addImageWithRandomKey(self, image):
+        self.addImage(randomLowercaseString(), image)
+
+    def addImage(self, key, image):
+        Repository.images[key] = image
+
 
 Repository = RepositoryWrapper()

homa-0.25/homa/classes/Window.py

@@ -0,0 +1,115 @@
+import numpy
+import cv2
+
+from ..helpers.kernel import createKernel
+from ..helpers.string import randomLowercaseString
+
+from ..classes.Repository import Repository
+
+from ..events import createMouseCallback
+
+from typing_extensions import Self
+from typing import List
+
+from ..shapes import color
+from ..shapes import stroke
+
+from ..main import setting
+
+
+class Window:
+    def __init__(self, width: int = 300, height: int = 300, image=None, title: str | None = None, channels: int = 3, dtype="uint8") -> None:
+        if title is None:
+            title = randomLowercaseString(10)
+
+        if image is None:
+            image = numpy.zeros([height, width, channels], dtype=dtype)
+
+        self.__title = title
+        self.__image = image
+        self.__events = {}
+
+    def show(self):
+        cv2.namedWindow(self.__title)
+        cv2.setMouseCallback(self.__title, createMouseCallback(self.__events))
+        Repository.imshow(self.__title, self.__image)
+
+    def title(self, newTitle: str) -> Self:
+        self.__title = newTitle
+        return self
+
+    def update(self, newImage) -> Self:
+        self.__image = newImage
+        self.refresh()
+        return self
+
+    def click(self, handler: callable) -> Self:
+        self.__events["click"] = (handler, self)
+        return self
+
+    def move(self, handler: callable) -> Self:
+        self.__events["mousemove"] = (handler, self)
+        return self
+
+    def white(self) -> Self:
+        self.__image = numpy.ones([
+            self.__image.shape[0],
+            self.__image.shape[1],
+            self.__image.shape[2]
+        ]) * (2 ** 8 - 1)
+        return self
+
+    def blur(self, kernel: int | List[int] = (7, 7)) -> Self:
+        self.update(cv2.blur(
+            self.__image,
+            createKernel(kernel),
+        ))
+
+        return self
+
+    def gaussian(self, kernel: int | List[int] = (7, 7)) -> Self:
+        self.update(cv2.GaussianBlur(
+            self.__image,
+            createKernel(kernel),
+            setting("sigma")[0],
+            setting("sigma")[1],
+        ))
+
+        return self
+
+    def median(self, kernel: int) -> Self:
+        self.update(cv2.medianBlur(
+            self.__image, kernel
+        ))
+
+        return self
+
+    def refresh(self):
+        Repository.imshow(self.__title, self.__image)
+
+    def circle(self, x: int, y: int, radius: int, circleColor: tuple | None = None, thickness: int | None = None):
+        if circleColor is not None:
+            color(*circleColor)
+
+        if thickness is not None:
+            stroke(thickness)
+
+        self.update(cv2.circle(
+            self.__image,
+            (x, y),
+            radius,
+            setting("color"),
+            setting("thickness")
+        ))
+
+    def getImage(self):
+        return self.__image
+
+    def getTitle(self):
+        return self.__title
+
+    def __getattr__(self, key):
+        if key == "shape":
+            return self.__image.shape
+
+        return None

homa-0.25/homa/events.py

@@ -0,0 +1,40 @@
+import cv2
+from inspect import signature
+from .classes.Repository import Repository
+
+event_map = {
+    "click":     cv2.EVENT_LBUTTONDOWN,
+    "rclick":    cv2.EVENT_RBUTTONDOWN,
+    "mclick":    cv2.EVENT_MBUTTONDOWN,
+    "mouseup":   cv2.EVENT_LBUTTONUP,
+    "rmouseup":  cv2.EVENT_RBUTTONUP,
+    "dblclick":  cv2.EVENT_LBUTTONDBLCLK,
+    "rdblclick": cv2.EVENT_RBUTTONDBLCLK,
+    "mousemove": cv2.EVENT_MOUSEMOVE
+}
+
+
+def createMouseCallback(events: dict):
+    def innerMouseCallback(event, x, y, flags, param):
+        for e, values in events.items():
+            if event != event_map[e]:
+                continue
+
+            handler, context = values
+            argumentCount = len(signature(handler).parameters)
+            if argumentCount == 2:
+                args = (x, y)
+            elif argumentCount == 3:
+                args = (x, y, context)
+            elif argumentCount == 4:
+                args = (x, y, context, flags)
+            elif argumentCount == 5:
+                args = (x, y, context, flags, param)
+            elif argumentCount == 1:
+                args = (context,)
+            elif args == 0:
+                args = tuple()
+
+            handler(*args)
+
+    return innerMouseCallback

homa-0.25/homa/helpers/alias.py

@@ -0,0 +1,18 @@
+from ..classes.Repository import Repository
+from ..classes.Collection import Collection
+from typing import List
+
+
+def repo(key: str | None = None, value: any = None) -> any:
+    if key is None and value is None:
+        return Repository.images
+
+    if key is not None and value is None:
+        return Repository.addImage(key, value)
+
+    Repository.addImage(key, value)
+    return True
+
+
+def collection(items: List[any]):
+    return Collection(items)

{homa-0.24 → homa-0.25}/homa/helpers/kernel.py

@@ -1,7 +1,7 @@
 from typing import Tuple
 
 
-def create_kernel(value: int | Tuple[int, int]) -> Tuple[int, int]:
+def createKernel(value: int | Tuple[int, int]) -> Tuple[int, int]:
     if isinstance(value, tuple):
         x, y = value
 

homa-0.25/homa/helpers/string.py

@@ -0,0 +1,16 @@
+import numpy
+import string
+
+
+def randomLowercaseString(length: int = 10):
+    return randomString(length, string.ascii_lowercase)
+
+
+def randomUppercaseString(length: int = 10):
+    return randomString(length, string.ascii_uppercase)
+
+
+def randomString(length: int = 10, letters: str = string.ascii_letters):
+    return "".join(
+        numpy.random.choice(list(letters), length)
+    )

homa-0.25/homa/main.py

@@ -0,0 +1,32 @@
+import cv2
+from .classes.Repository import Repository
+
+
+def destroy(key: str | None = None) -> None:
+    if key is not None:
+        cv2.destroyWindow(key)
+        return
+
+    cv2.destroyAllWindows()
+
+
+def show(*windows, **settings):
+    for window in windows:
+        window.show()
+
+    if settings["wait"] == True:
+        cv2.waitKey()
+
+
+def showWait(*args, **kwargs):
+    kwargs["wait"] = True
+    show(*args, **kwargs)
+
+
+def setting(key: str, value: any = None) -> any:
+    if value is not None:
+        Repository.settings[key] = value
+        return True
+
+    setting_value = Repository.settings[key]
+    return setting_value if setting_value else None

homa-0.25/homa/shapes.py

@@ -0,0 +1,50 @@
+import cv2
+from .main import setting
+from .helpers.alias import repo
+from typing import Tuple
+import numpy
+
+
+def stroke(value: int = 1):
+    setting("thickness", value)
+
+
+def fill(*args):
+    setting("thickness", -1)
+
+    if len(args) == 3:
+        color(*args)
+
+
+def randomColor() -> Tuple[int, int, int]:
+    r = numpy.random.randint(0, 255)
+    g = numpy.random.randint(0, 255)
+    b = numpy.random.randint(0, 255)
+
+    return (b, g, r)
+
+
+def color(*args):
+    if len(args) == 1 and isinstance(args[0], str) and args[0] in ["random", "rand"]:
+        args = randomColor()
+
+    setting("color", args)
+
+
+def circle(key: str, x: int, y: int, radius: int = 1):
+    cv2.circle(
+        repo(key),
+        (x, y),
+        radius,
+        setting("color"),
+        setting("thickness")
+    )
+
+
+def rect(key: str, x: int, y: int, width: int, height: int):
+    cv2.rectangle(
+        repo(key),
+        (x - width // 2, y - height // 2), (x + width // 2, y + height // 2),
+        thickness=setting("thickness"),
+        color=setting("color")
+    )

{homa-0.24 → homa-0.25}/homa/spaces.py

@@ -1,8 +1,24 @@
 from typing import Tuple
 from .helpers.alias import repo
+import cv2
 
 
-def rgb(key: str) -> Tuple[int, int, int]:
+def hsv(key: str):
+    image = repo(key)
+    cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+
+    h = image[:, :, 0]
+    s = image[:, :, 1]
+    v = image[:, :, 2]
+
+    return (h, s, v)
+
+
+def bgr(key: str) -> Tuple[int, int, int]:
+    return rgb(key, bgr_flag=True)
+
+
+def rgb(key: str, bgr_flag: bool = False) -> Tuple[int, int, int]:
     image = repo(key)
 
     if image.shape[2] == 3:
@@ -13,6 +29,9 @@ def rgb(key: str) -> Tuple[int, int, int]:
         g = image[:, :, 0]
         r = image[:, :, 0]
 
+        if bgr_flag:
+            return (b, g, r)
+
         return (r, g, b)
 
     if image.shape[2] == 1:

{homa-0.24 → homa-0.25}/homa.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: homa
-Version: 0.24
+Version: 0.25
 Maintainer: Taha Shieenavaz
 Maintainer-email: tahashieenavaz@gmail.com
 Description-Content-Type: text/markdown

{homa-0.24 → homa-0.25}/homa.egg-info/SOURCES.txt

@@ -5,8 +5,6 @@ homa/__init__.py
 homa/camera.py
 homa/constants.py
 homa/events.py
-homa/filters.py
-homa/helpers.py
 homa/main.py
 homa/orientation.py
 homa/shapes.py
@@ -17,12 +15,15 @@ homa.egg-info/dependency_links.txt
 homa.egg-info/requires.txt
 homa.egg-info/top_level.txt
 homa/classes/Collection.py
+homa/classes/Image.py
 homa/classes/Logger.py
 homa/classes/Repository.py
+homa/classes/Window.py
 homa/classes/__init__.py
 homa/helpers/__init__.py
 homa/helpers/alias.py
 homa/helpers/environment.py
 homa/helpers/kernel.py
+homa/helpers/string.py
 tests/__init__.py
 tests/test_images.py

homa-0.24/homa/events.py

@@ -1,70 +0,0 @@
-# enum MouseEventTypes
-# {
-#     EVENT_MOUSEMOVE     = 0,
-#     EVENT_LBUTTONDOWN   = 1,
-#     EVENT_RBUTTONDOWN   = 2,
-#     EVENT_MBUTTONDOWN   = 3,
-#     EVENT_LBUTTONUP     = 4,
-#     EVENT_RBUTTONUP     = 5,
-#     EVENT_MBUTTONUP     = 6,
-#     EVENT_LBUTTONDBLCLK = 7,
-#     EVENT_RBUTTONDBLCLK = 8,
-#     EVENT_MBUTTONDBLCLK = 9,
-#     EVENT_MOUSEWHEEL    = 10,
-#     EVENT_MOUSEHWHEEL   = 11,
-# };
-import cv2
-from .main import win
-from inspect import signature
-
-event_map = {
-    "click":     cv2.EVENT_LBUTTONDOWN,
-    "rclick":    cv2.EVENT_RBUTTONDOWN,
-    "mclick":    cv2.EVENT_MBUTTONDOWN,
-    "mouseup":   cv2.EVENT_LBUTTONUP,
-    "rmouseup":  cv2.EVENT_RBUTTONUP,
-    "dblclick":  cv2.EVENT_LBUTTONDBLCLK,
-    "rdblclick": cv2.EVENT_RBUTTONDBLCLK,
-    "move":      cv2.EVENT_MOUSEMOVE
-}
-
-
-def create_wrapper_function(event_name: str, handler: callable):
-    def wrapper_function(event, x, y, flags, param):
-        if event != event_map[event_name]:
-            return
-
-        argument_count = len(signature(handler).parameters)
-        if argument_count == 2:
-            handler(x, y)
-        elif argument_count == 3:
-            handler(x, y, flags)
-        elif argument_count == 4:
-            handler(x, y, flags, param)
-
-    return wrapper_function
-
-
-def onClick(key: str, handler: callable):
-    win(key)
-    cv2.setMouseCallback(key, create_wrapper_function("click", handler))
-
-
-def onRightClick(key: str, handler: callable):
-    win(key)
-    cv2.setMouseCallback(key, create_wrapper_function("rclick", handler))
-
-
-def onMouseUp(key: str, handler: callable):
-    win(key)
-    cv2.setMouseCallback(key, create_wrapper_function("mouseup", handler))
-
-
-def onMove(key: str, handler: callable):
-    win(key)
-    cv2.setMouseCallback(key, create_wrapper_function("mousemove", handler))
-
-
-def onDoubleClick(key: str, handler: callable):
-    win(key)
-    cv2.setMouseCallback(key, create_wrapper_function("dblclick", handler))

homa-0.24/homa/filters.py

@@ -1,41 +0,0 @@
-from typing import List
-from .classes.Repository import Repository
-from .helpers.kernel import create_kernel
-import cv2
-
-
-def blur(key: str, kernel: int | List[int] = (7, 7), new_key: str | None = None) -> None:
-    if new_key is None:
-        new_key = key
-
-    Repository.images[new_key] = cv2.blur(
-        Repository.images[key],
-        create_kernel(kernel)
-    )
-
-
-def median(key: str, kernel: int | List[int] = (7, 7), new_key: str | None = None) -> None:
-    if new_key is None:
-        new_key = key
-
-    Repository.images[new_key] = cv2.medianBlur(
-        Repository.images[key],
-        create_kernel(kernel)
-    )
-
-
-def sigma(x: float = 0, y: float = 0) -> None:
-    Repository.sigmaX = x
-    Repository.sigmaY = y
-
-
-def gaussian(key: str, kernel: None | List[int] = None, new_key: str | None = None) -> None:
-    if new_key is None:
-        new_key = key
-
-    Repository.images[new_key] = cv2.GaussianBlur(
-        Repository.images[key],
-        create_kernel(kernel),
-        sigmaX=Repository.sigmaX,
-        sigmaY=Repository.sigmaY
-    )

homa-0.24/homa/helpers/alias.py

@@ -1,14 +0,0 @@
-from ..classes.Repository import Repository
-from ..classes.Collection import Collection
-from typing import List
-
-
-def repo(key: str | None = None):
-    if key is None:
-        return Repository.images
-
-    return Repository.images[key]
-
-
-def collection(items: List[any]):
-    return Collection(items)

homa-0.24/homa/main.py

@@ -1,74 +0,0 @@
-import cv2
-from .classes.Logger import Logger
-from .classes.Repository import Repository
-
-
-def destroy(key: str | None = None) -> None:
-    if key is not None:
-        cv2.destroyWindow(key)
-        return
-
-    cv2.destroyAllWindows()
-
-
-def win(key: str):
-    cv2.namedWindow(key)
-
-
-def path(directory: str) -> None:
-    Repository.directory = directory
-
-
-def write(key: str, filename: str) -> None:
-    cv2.imwrite(
-        filename=filename,
-        img=Repository.images[key]
-    )
-
-
-def save(*args, **kwargs) -> None:
-    write(args, kwargs)
-
-
-def image(filename: str, key: str | None = None, color: bool = True) -> None:
-    # TODO: add no extension in the file
-    if key is None:
-        key = filename.split(".")[0]
-
-    Repository.images[key] = cv2.imread(filename, int(color))
-    return Repository.images[key]
-
-
-def wait(delay=0):
-    cv2.waitKey(delay)
-
-
-def showWait(*args, **kwargs):
-    kwargs["wait"] = True
-    show(*args, **kwargs)
-
-
-def show(key: any = None, wait: bool = False, window: str = "Homa Window") -> None:
-    # TODO: add functionality to distinguish between camera and images
-
-    if key is not None and not isinstance(key, str):
-        Repository.imshow(window, key)
-
-    elif key is None:
-        for key, image in Repository.images.items():
-            Repository.imshow(key, image)
-            Repository.windows[key] = key
-
-    elif key is not None:
-        if key in Repository.images:
-            Repository.imshow(key, Repository.images[key])
-            Repository.windows[key] = key
-        else:
-            Logger.danger(f"No image found with key {key}")
-
-    if wait:
-        cv2.waitKey(0)
-
-
-def refresh(key: str) -> None:
-    cv2.imshow(Repository.windows[key], Repository.images[key])

homa-0.24/homa/shapes.py

@@ -1,9 +0,0 @@
-import cv2
-from .main import refresh
-from .helpers.alias import repo
-from .classes.Repository import Repository
-
-
-def circle(key: str, x: int = 0, y: int = 0, r: int = 1, color=(0, 0, 255), thickness: int = 1):
-    cv2.circle(repo(key), (x, y), r, color, thickness)
-    refresh(key)