homa 0.23__py3-none-any.whl → 0.25__py3-none-any.whl

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/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/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/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/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/events.py

@@ -1,21 +1,6 @@
-# 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
+from .classes.Repository import Repository
 
 event_map = {
     "click":     cv2.EVENT_LBUTTONDOWN,
@@ -25,46 +10,31 @@ event_map = {
     "rmouseup":  cv2.EVENT_RBUTTONUP,
     "dblclick":  cv2.EVENT_LBUTTONDBLCLK,
     "rdblclick": cv2.EVENT_RBUTTONDBLCLK,
-    "move":      cv2.EVENT_MOUSEMOVE
+    "mousemove": 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))
+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/helpers/alias.py

@@ -1,13 +1,17 @@
 from ..classes.Repository import Repository
-from ..classes import Collection
+from ..classes.Collection import Collection
 from typing import List
 
 
-def repo(key: str|None = None):
-    if key is None:
+def repo(key: str | None = None, value: any = None) -> any:
+    if key is None and value is None:
         return Repository.images
 
-    return Repository.images[key]
+    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]):

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/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/main.py

@@ -1,5 +1,4 @@
 import cv2
-from .classes.Logger import Logger
 from .classes.Repository import Repository
 
 
@@ -11,36 +10,12 @@ def destroy(key: str | None = None) -> None:
     cv2.destroyAllWindows()
 
 
-def win(key: str):
-    cv2.namedWindow(key)
+def show(*windows, **settings):
+    for window in windows:
+        window.show()
 
-
-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)
+    if settings["wait"] == True:
+        cv2.waitKey()
 
 
 def showWait(*args, **kwargs):
@@ -48,28 +23,10 @@ def showWait(*args, **kwargs):
     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)
-        Repository.windows[key] = window
-
-    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 setting(key: str, value: any = None) -> any:
+    if value is not None:
+        Repository.settings[key] = value
+        return True
 
-def refresh(key: str) -> None:
-    cv2.imshow(Repository.windows[key], Repository.images[key])
+    setting_value = Repository.settings[key]
+    return setting_value if setting_value else None

homa/shapes.py

@@ -1,9 +1,50 @@
 import cv2
-from .main import refresh
+from .main import setting
 from .helpers.alias import repo
-from .classes.Repository import Repository
+from typing import Tuple
+import numpy
 
 
-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)
+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/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.23.dist-info → homa-0.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: homa
-Version: 0.23
+Version: 0.25
 Maintainer: Taha Shieenavaz
 Maintainer-email: tahashieenavaz@gmail.com
 Description-Content-Type: text/markdown
@@ -27,6 +27,10 @@ Images could be loaded with the `image` helper, that accepts the file name and a
 from homa import *
 
 image("horse.jpg", "horse")
+show("horse", wait=True)
+
+# or alternatively
+showWait("horse")
 ```
 
 Alternatively, following code will load the file into the repository with a key of everything before the last in the filename.
@@ -35,6 +39,7 @@ Alternatively, following code will load the file into the repository with a key
 from homa import *
 
 image("horse.jpg") # stored as "horse"
+showWait("horse")
 ```
 
 ## Smoothing
@@ -67,6 +72,20 @@ gaussian("horse", 9, "gaussian blurred horse")   # as a new key in the repositor
 showWait("gaussian blurred horse")
 ```
 
+### Median Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+median("horse", 7)                           # rewrites "horse" key
+median("horse", (7, 19))                     # rewrites "horse" key
+median("horse", 9, "median blurred horse")   # as a new key in the repository
+
+showWait("median blurred horse")
+```
+
 ## Stacking
 
 ```python

homa-0.25.dist-info/RECORD

@@ -0,0 +1,28 @@
+homa/__init__.py,sha256=N3G5CLd0gFelUgQzWFj0IGI_8TUMlX8GfyWFp9lrWb0,228
+homa/camera.py,sha256=erui7LWTqZQNBVVxIChw-JCrYchpUjgplgU7d5jSR-E,527
+homa/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+homa/events.py,sha256=WTVUPh0MqRiknA390_vvMSFNhdFeX9iZCrBphGbdTHY,1223
+homa/filters.py,sha256=lEwUZtCUSH59D4J9lWQ-d0ObSk_ikZBGRnNAZWMnpPo,1058
+homa/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+homa/main.py,sha256=jFVKuW1mNS21As7pY4XnXVQ6TaDOHxC2dAmUzE5HG-U,660
+homa/orientation.py,sha256=kR7mEmbjCdyxNeQ7UuGpwTFD6EaNbXmErzaln3gpzfk,804
+homa/shapes.py,sha256=0_THluO4mUg1F4FmP4YQuB5A3W4Ns9Z2tPmhmSyTBlI,1044
+homa/spaces.py,sha256=W2UjzEP54dDgOV4c8xNCu8qJ__j-hwRbnyIOGnwpHwE,804
+homa/classes/Collection.py,sha256=7hskbC8wxTAC3hHmFYXtzR5W05lsA4GaYTzjiez_6Zg,222
+homa/classes/Image.py,sha256=kpIZQjJMUcT9b2V1daX87KFQooAtsHUDR4Fcgk9Qfco,490
+homa/classes/Logger.py,sha256=2VjXJzBLMW5joArFpu2wGrbWUw7S-77z7LNhKUG1Iow,93
+homa/classes/Repository.py,sha256=vvX36nK-sN0eQAf7vNR2KVwosj76VCeQwaGT5pw8Lkw,840
+homa/classes/Window.py,sha256=orhuI7RmM5I_bmlWicR1G-be74EEexHixCuYIX46Y3E,2941
+homa/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+homa/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+homa/helpers/alias.py,sha256=Gv4esGK5SWKbmqvFUAKUfzDqlofdC27ZtndXxfaxE7E,453
+homa/helpers/environment.py,sha256=I7rD9B5zv3W8lkspntcshm5PZZRRSW81OqIjKOdZW6U,78
+homa/helpers/kernel.py,sha256=QIbwvx3XzG23TMCj7nUOgSirx3WK_29lkBeVlp2uzQw,329
+homa/helpers/string.py,sha256=nyNcQgZ9l5zf0QwI5gZCMX4dqMWi63VCqtl26ExDZsI,385
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_images.py,sha256=4k5tDcMc2YZOKAq3wNQnbJ_cO1Y_DQ-YUn82yzy__ww,772
+homa-0.25.dist-info/LICENSE,sha256=js3WDbJn9k5EN6sy1uuP2QBXxyPgS5DjO4Bf5yE35hQ,1072
+homa-0.25.dist-info/METADATA,sha256=wcp0pCuuQkPF9GxcanpkT6Ci_b1f17ogjsQiyAtYgfo,2472
+homa-0.25.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+homa-0.25.dist-info/top_level.txt,sha256=i1-Cx_lkcOD5QJEK9JYp1uDEBhtshAN7No-99mhpOZ0,11
+homa-0.25.dist-info/RECORD,,

homa-0.23.dist-info/RECORD

@@ -1,25 +0,0 @@
-homa/__init__.py,sha256=fImpDDouSHoDdq-q-O0p8RirzGTgXXRI4Ol_LU4f9sI,182
-homa/camera.py,sha256=PHZb3sX0EFdwLDixYindluVDftg6JZlG_Ssbd3hgiNE,464
-homa/constants.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-homa/events.py,sha256=Q077YcaM8-VjfKYhPQCQ7dasdu-mACKMf5cupiLNDoY,1946
-homa/filters.py,sha256=lEwUZtCUSH59D4J9lWQ-d0ObSk_ikZBGRnNAZWMnpPo,1058
-homa/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-homa/main.py,sha256=1bRjOrU-Frdlj5a1cLvM2pUVLpk3K9EK6J0bFBC5hQU,1774
-homa/orientation.py,sha256=kR7mEmbjCdyxNeQ7UuGpwTFD6EaNbXmErzaln3gpzfk,804
-homa/shapes.py,sha256=MVZWkOtqkby8KiL04mK4nrirDGeQM3k8dDEZIpDt8AU,283
-homa/spaces.py,sha256=yEIXofkM0ebvRBbRp-e7epETHW_xmwSrCoTyYUYV-uA,460
-homa/classes/Collection.py,sha256=7hskbC8wxTAC3hHmFYXtzR5W05lsA4GaYTzjiez_6Zg,222
-homa/classes/Logger.py,sha256=2VjXJzBLMW5joArFpu2wGrbWUw7S-77z7LNhKUG1Iow,93
-homa/classes/Repository.py,sha256=w7hlbj6QIWNV2lWNs5-j6OXacSm6UGQ9DtX1zxaUA7c,589
-homa/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-homa/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-homa/helpers/alias.py,sha256=a-wq7UUnT_nYIh5nP-bc_EZb-0zF5VfnKwVhSuLSjw8,288
-homa/helpers/environment.py,sha256=I7rD9B5zv3W8lkspntcshm5PZZRRSW81OqIjKOdZW6U,78
-homa/helpers/kernel.py,sha256=sAdIW92coy0BoAPlk5Ez4sE5iFU207TU7OfjP7sPSkM,330
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_images.py,sha256=4k5tDcMc2YZOKAq3wNQnbJ_cO1Y_DQ-YUn82yzy__ww,772
-homa-0.23.dist-info/LICENSE,sha256=js3WDbJn9k5EN6sy1uuP2QBXxyPgS5DjO4Bf5yE35hQ,1072
-homa-0.23.dist-info/METADATA,sha256=rBFjHYZz3mSqydiHvPLzLoTGAbMtkJF18zVnqPZvcUk,2071
-homa-0.23.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-homa-0.23.dist-info/top_level.txt,sha256=i1-Cx_lkcOD5QJEK9JYp1uDEBhtshAN7No-99mhpOZ0,11
-homa-0.23.dist-info/RECORD,,