homa 0.21__tar.gz → 0.23__tar.gz

homa-0.23/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: homa
+Version: 0.23
+Maintainer: Taha Shieenavaz
+Maintainer-email: tahashieenavaz@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+<p align="center">
+	<img
+		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
+		width=500
+	/>
+</p>
+
+<hr />
+
+Homa is an easy way to start learning Computer Vision with OpenCV.
+
+## Loading Images
+
+Images could be loaded with the `image` helper, that accepts the file name and a key for the repository.
+
+```python
+from homa import *
+
+image("horse.jpg", "horse")
+```
+
+Alternatively, following code will load the file into the repository with a key of everything before the last in the filename.
+
+```python
+from homa import *
+
+image("horse.jpg") # stored as "horse"
+```
+
+## Smoothing
+
+### Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+blur("horse", 7)                    # rewrites "horse" key
+blur("horse", (7, 19))              # rewrites "horse" key
+blur("horse", 9, "blurred horse")   # as a new key in the repository
+
+showWait("blurred horse")
+```
+
+### Gaussian Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+gaussian("horse", 7)                             # rewrites "horse" key
+gaussian("horse", (7, 19))                       # rewrites "horse" key
+gaussian("horse", 9, "gaussian blurred horse")   # as a new key in the repository
+
+showWait("gaussian blurred horse")
+```
+
+## Stacking
+
+```python
+from homa import *
+
+image("horse.jpg")
+blur("horse", 9, "blurred horse")
+
+show(
+	vstack("horse", "blurred horse"),
+	window="Vstacked"
+)
+
+showWait(
+	hstack("horse", "blurred horse"),
+	window="Hstacked"
+)
+```
+
+## Camera
+
+Camera frames could be access from the repository with a key of `camera`.
+
+```python
+from homa import *
+
+for _ in camera():
+	show("camera")
+```
+
+You can simply combine camera frames with the supported effects.
+
+```python
+from homa import *
+
+for _ in camera():
+	blur("camera", 13, "blurred camera")
+
+	show(
+		vstack("camera", "blurred camera"),
+		window="Camera Effect"
+	)
+```

homa-0.23/README.md

@@ -0,0 +1,102 @@
+<p align="center">
+	<img
+		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
+		width=500
+	/>
+</p>
+
+<hr />
+
+Homa is an easy way to start learning Computer Vision with OpenCV.
+
+## Loading Images
+
+Images could be loaded with the `image` helper, that accepts the file name and a key for the repository.
+
+```python
+from homa import *
+
+image("horse.jpg", "horse")
+```
+
+Alternatively, following code will load the file into the repository with a key of everything before the last in the filename.
+
+```python
+from homa import *
+
+image("horse.jpg") # stored as "horse"
+```
+
+## Smoothing
+
+### Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+blur("horse", 7)                    # rewrites "horse" key
+blur("horse", (7, 19))              # rewrites "horse" key
+blur("horse", 9, "blurred horse")   # as a new key in the repository
+
+showWait("blurred horse")
+```
+
+### Gaussian Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+gaussian("horse", 7)                             # rewrites "horse" key
+gaussian("horse", (7, 19))                       # rewrites "horse" key
+gaussian("horse", 9, "gaussian blurred horse")   # as a new key in the repository
+
+showWait("gaussian blurred horse")
+```
+
+## Stacking
+
+```python
+from homa import *
+
+image("horse.jpg")
+blur("horse", 9, "blurred horse")
+
+show(
+	vstack("horse", "blurred horse"),
+	window="Vstacked"
+)
+
+showWait(
+	hstack("horse", "blurred horse"),
+	window="Hstacked"
+)
+```
+
+## Camera
+
+Camera frames could be access from the repository with a key of `camera`.
+
+```python
+from homa import *
+
+for _ in camera():
+	show("camera")
+```
+
+You can simply combine camera frames with the supported effects.
+
+```python
+from homa import *
+
+for _ in camera():
+	blur("camera", 13, "blurred camera")
+
+	show(
+		vstack("camera", "blurred camera"),
+		window="Camera Effect"
+	)
+```

homa-0.23/homa/__init__.py

@@ -0,0 +1,9 @@
+from .main import *
+from .filters import *
+from .camera import *
+from .orientation import *
+from .spaces import *
+from .events import *
+from .shapes import *
+
+from .helpers import *

homa-0.23/homa/camera.py

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

{homa-0.21 → homa-0.23}/homa/classes/Repository.py

@@ -1,4 +1,4 @@
-from ..helpers import is_colab
+from ..helpers.environment import is_colab
 
 
 class RepositoryWrapper:
@@ -8,8 +8,7 @@ class RepositoryWrapper:
 
         self.directory = "./"
         self.images = {}
-        self.cameras = {}
-        self.window_counter = 0
+        self.windows = {}
 
         if is_colab():
             from google.colab.patches import cv2_imshow as imshow
@@ -24,9 +23,5 @@ class RepositoryWrapper:
 
         self.imshow = final_imshow
 
-    def get_counter(self):
-        self.window_counter += 1
-        return self.window_counter
-
 
 Repository = RepositoryWrapper()

homa-0.23/homa/events.py

@@ -0,0 +1,70 @@
+# 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.23/homa/filters.py

@@ -0,0 +1,41 @@
+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.23/homa/helpers/alias.py

@@ -0,0 +1,14 @@
+from ..classes.Repository import Repository
+from ..classes 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.23/homa/helpers/environment.py

@@ -0,0 +1,5 @@
+import sys
+
+
+def is_colab() -> bool:
+    return 'google.colab' in sys.modules

homa-0.23/homa/helpers/kernel.py

@@ -0,0 +1,15 @@
+from typing import Tuple
+
+
+def create_kernel(value: int | Tuple[int, int]) -> Tuple[int, int]:
+    if isinstance(value, tuple):
+        x, y = value
+
+        x = x - 1 if x % 2 == 0 else x
+        y = y - 1 if y % 2 == 0 else y
+
+        return (x, y)
+
+    value = value - 1 if value % 2 == 0 else value
+
+    return (value, value)

homa-0.23/homa/main.py

@@ -0,0 +1,75 @@
+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)
+        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 refresh(key: str) -> None:
+    cv2.imshow(Repository.windows[key], Repository.images[key])

homa-0.23/homa/orientation.py

@@ -0,0 +1,38 @@
+from .classes.Repository import Repository
+from .helpers.alias import collection
+import numpy
+
+
+def stack(*keys, **settings):
+    default_settings = {
+        "axis": 1,
+        "new_key": None
+    }
+
+    settings = {
+        **default_settings,
+        **settings
+    }
+
+    if all(isinstance(item, str) for item in keys):
+        keys = collection(keys).map(lambda key: Repository.images[key])
+
+    stacked_image = numpy.concatenate(
+        keys,
+        axis=settings["axis"]
+    )
+
+    if settings["new_key"] is not None:
+        Repository.images[settings["new_key"]] = stacked_image
+
+    return stacked_image
+
+
+def vstack(*keys, **settings):
+    settings["axis"] = 1
+    return stack(*keys, **settings)
+
+
+def hstack(*keys, **settings):
+    settings["axis"] = 0
+    return stack(*keys, **settings)

homa-0.23/homa/shapes.py

@@ -0,0 +1,9 @@
+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)

homa-0.23/homa/spaces.py

@@ -0,0 +1,20 @@
+from typing import Tuple
+from .helpers.alias import repo
+
+
+def rgb(key: str) -> Tuple[int, int, int]:
+    image = repo(key)
+
+    if image.shape[2] == 3:
+        # found three channels in stored image
+        # meaning that it has been loaded as a color image
+
+        b = image[:, :, 0]
+        g = image[:, :, 0]
+        r = image[:, :, 0]
+
+        return (r, g, b)
+
+    if image.shape[2] == 1:
+        gray = image[:, :, 0]
+        return (gray, gray, gray)

homa-0.23/homa.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.1
+Name: homa
+Version: 0.23
+Maintainer: Taha Shieenavaz
+Maintainer-email: tahashieenavaz@gmail.com
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+<p align="center">
+	<img
+		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
+		width=500
+	/>
+</p>
+
+<hr />
+
+Homa is an easy way to start learning Computer Vision with OpenCV.
+
+## Loading Images
+
+Images could be loaded with the `image` helper, that accepts the file name and a key for the repository.
+
+```python
+from homa import *
+
+image("horse.jpg", "horse")
+```
+
+Alternatively, following code will load the file into the repository with a key of everything before the last in the filename.
+
+```python
+from homa import *
+
+image("horse.jpg") # stored as "horse"
+```
+
+## Smoothing
+
+### Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+blur("horse", 7)                    # rewrites "horse" key
+blur("horse", (7, 19))              # rewrites "horse" key
+blur("horse", 9, "blurred horse")   # as a new key in the repository
+
+showWait("blurred horse")
+```
+
+### Gaussian Blur
+
+```python
+from homa import *
+
+image("horse.jpg")
+
+gaussian("horse", 7)                             # rewrites "horse" key
+gaussian("horse", (7, 19))                       # rewrites "horse" key
+gaussian("horse", 9, "gaussian blurred horse")   # as a new key in the repository
+
+showWait("gaussian blurred horse")
+```
+
+## Stacking
+
+```python
+from homa import *
+
+image("horse.jpg")
+blur("horse", 9, "blurred horse")
+
+show(
+	vstack("horse", "blurred horse"),
+	window="Vstacked"
+)
+
+showWait(
+	hstack("horse", "blurred horse"),
+	window="Hstacked"
+)
+```
+
+## Camera
+
+Camera frames could be access from the repository with a key of `camera`.
+
+```python
+from homa import *
+
+for _ in camera():
+	show("camera")
+```
+
+You can simply combine camera frames with the supported effects.
+
+```python
+from homa import *
+
+for _ in camera():
+	blur("camera", 13, "blurred camera")
+
+	show(
+		vstack("camera", "blurred camera"),
+		window="Camera Effect"
+	)
+```

{homa-0.21 → homa-0.23}/homa.egg-info/SOURCES.txt

@@ -2,9 +2,15 @@ LICENSE
 README.md
 setup.py
 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
+homa/spaces.py
 homa.egg-info/PKG-INFO
 homa.egg-info/SOURCES.txt
 homa.egg-info/dependency_links.txt
@@ -13,4 +19,10 @@ homa.egg-info/top_level.txt
 homa/classes/Collection.py
 homa/classes/Logger.py
 homa/classes/Repository.py
-homa/classes/__init__.py
+homa/classes/__init__.py
+homa/helpers/__init__.py
+homa/helpers/alias.py
+homa/helpers/environment.py
+homa/helpers/kernel.py
+tests/__init__.py
+tests/test_images.py

homa-0.23/homa.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+homa
+tests

homa-0.23/tests/test_images.py

@@ -0,0 +1,27 @@
+from homa import *
+
+import unittest
+
+
+class LoadingImagesTest(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def test_can_load_images_into_repository(self):
+        image("italy.jpg", "italy")
+        self.assertIn("italy", repo())
+
+    def test_it_does_not_load_extra_images(self):
+        image("italy.jpg", "italy")
+        self.assertEqual(len(repo()), 1)
+
+        image("italy.jpg", "italy again")
+        self.assertEqual(len(repo()), 2)
+
+    def test_it_can_load_images_as_black_and_white(self):
+        image("italy.jpg", "italy", color=False)
+        self.assertEqual(len(repo("italy").shape), 2)
+
+    def test_it_can_load_images_as_colorful(self):
+        image("italy.jpg", "italy", color=True)
+        self.assertEqual(len(repo("italy").shape), 3)

homa-0.21/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: homa
-Version: 0.21
-Maintainer: Taha Shieenavaz
-Maintainer-email: tahashieenavaz@gmail.com
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-<p align="center">
-	<img
-		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
-		width=400
-	/>
-</p>
-
-<hr />

homa-0.21/README.md

@@ -1,8 +0,0 @@
-<p align="center">
-	<img
-		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
-		width=400
-	/>
-</p>
-
-<hr />

homa-0.21/homa/__init__.py

@@ -1 +0,0 @@
-from .main import *

homa-0.21/homa/helpers.py

@@ -1,16 +0,0 @@
-import sys
-from typing import List
-from .classes.Collection import Collection
-from .classes.Logger import Logger
-
-
-def is_colab() -> bool:
-    return 'google.colab' in sys.modules
-
-
-def collection(items: List[any]):
-    return Collection(items)
-
-
-def danger(message: str) -> None:
-    Logger.danger(message)

homa-0.21/homa/main.py

@@ -1,109 +0,0 @@
-import cv2
-import numpy
-from typing import List
-from .helpers import collection
-from .helpers import danger
-from .helpers import is_colab
-
-from .classes.Repository import Repository
-
-
-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(key: str, filename: str) -> None:
-    write(key, filename)
-
-
-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
-
-    Repository.images[key] = cv2.imread(filename, int(color))
-    return Repository.images[key]
-
-
-def show(key: any = None) -> None:
-    # TODO: add functionality to distinguish between camera and images
-
-    if key is not None and not isinstance(key, str):
-        Repository.imshow(f"Window #{Repository.get_counter()}", key)
-
-    elif key is None:
-        for key, image in Repository.images.items():
-            Repository.imshow(key, image)
-
-    elif key is not None:
-        if key in Repository.images:
-            Repository.imshow(key, Repository.images[key])
-        else:
-            danger(f"No image found with key {key}")
-
-    cv2.waitKey(0)
-
-
-def camera():
-    capture = cv2.VideoCapture()
-    _, frame = capture.read()
-    Repository.camera_frame = frame
-
-
-def stack(keys: List[str], new_key: str, axis: int):
-    Repository.images[new_key] = numpy.concatenate(
-        collection(keys).map(lambda key: Repository.images[key]),
-        axis=axis
-    )
-
-
-def vstack(keys: List[str], new_key: str) -> None:
-    stack(keys, new_key, 1)
-
-
-def hstack(keys: List[str] | str, new_key: str | None = None):
-    if isinstance(keys, str) and new_key is None:
-        hstack([keys], keys)
-        return
-
-    stack(keys, new_key, 0)
-
-
-def blur(key: str, kernel: int | List[int] = (7, 7), new_key: str | None = None):
-    if new_key is None:
-        new_key = key
-
-    if isinstance(kernel, int):
-        kernel = (kernel, kernel)
-
-    Repository.images[new_key] = cv2.blur(
-        Repository.images[key],
-        kernel
-    )
-
-
-def sigma(x: float = 0, y: float = 0):
-    Repository.sigmaX = x
-    Repository.sigmaY = y
-
-
-def gaussian(key: str, kernel: None | List[int] = None, new_key: str | None = None):
-    if new_key is None:
-        new_key = key
-
-    if isinstance(kernel, int):
-        kernel = (kernel, kernel)
-
-    Repository.images[new_key] = cv2.GaussianBlur(
-        Repository.images[key],
-        kernel,
-        sigmaX=Repository.sigmaX,
-        sigmaY=Repository.sigmaY
-    )

homa-0.21/homa.egg-info/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: homa
-Version: 0.21
-Maintainer: Taha Shieenavaz
-Maintainer-email: tahashieenavaz@gmail.com
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-<p align="center">
-	<img
-		src="https://raw.githubusercontent.com/tahashieenavaz/homa/main/art/homa.svg"
-		width=400
-	/>
-</p>
-
-<hr />

homa-0.21/homa.egg-info/top_level.txt

@@ -1 +0,0 @@
-homa