albucore 0.0.1__tar.gz

albucore-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vladimir Iglovikov
+
+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.

albucore-0.0.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: albucore
+Version: 0.0.1
+Summary: A high-performance image processing library designed to optimize and extend the Albumentations library with specialized functions for advanced image transformations. Perfect for developers working in computer vision who require efficient and scalable image augmentation.
+Home-page: https://github.com/albumentations-team/albucore
+Author: Vladimir I. Iglovikov
+License: MIT
+Keywords: Image Processing,Computer Vision,Image Augmentation,Albumentations,Optimization,Machine Learning,Deep Learning,Python Imaging,Data Augmentation,Performance,Efficiency,High-Performance,CV,OpenCV,Automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.4
+Requires-Dist: tomli>=2.0.1
+Requires-Dist: opencv-python-headless>=4.9.0
+
+# Albucore
+
+Albucore is a high-performance image processing library designed to optimize operations on images using Python and OpenCV, building upon the foundations laid by the popular Albumentations library. It offers specialized optimizations for different image data types and aims to provide faster processing times through efficient algorithm implementations.
+
+## Features
+
+- Optimized image multiplication operations for both `uint8` and `float32` data types.
+- Support for single-channel and multi-channel images.
+- Custom decorators to manage channel dimensions and output constraints.
+
+## Installation
+
+Install Albucore using pip:
+
+```bash
+pip install -U albucore
+```
+
+## Example
+
+Here's how you can use Albucore to multiply an image by a constant or a vector:
+
+```python
+import cv2
+import numpy as np
+from albucore import multiply
+
+# Load an image
+img = cv2.imread('path_to_your_image.jpg')
+
+# Multiply by a constant
+multiplied_image = multiply(img, 1.5)
+
+# Multiply by a vector
+multiplier = [1.5, 1.2, 0.9]  # Different multiplier for each channel
+multiplied_image = multiply(img, multiplier)
+```
+
+## Benchmarks
+
+### Benchmark Results for 1000 Images of `float32` Type (256, 256, 1)
+
+|                  | albucore     | opencv           | numpy            |
+| ---------------- | ------------ | ---------------- | ---------------- |
+| MultiplyConstant | 12925 ± 1237 | 10963 ± 1053     | **14040 ± 2063** |
+| MultiplyVector   | 3832 ± 512   | **10824 ± 1005** | 8986 ± 511       |
+
+### Benchmark Results for 1000 Images of `uint8` Type (256, 256, 1)
+
+|                  | albucore         | opencv      | numpy      |
+| ---------------- | ---------------- | ----------- | ---------- |
+| MultiplyConstant | **24131 ± 1129** | 11622 ± 175 | 6969 ± 643 |
+| MultiplyVector   | **24279 ± 908**  | 11756 ± 152 | 6936 ± 408 |
+
+Albucore provides significant performance improvements for image processing tasks. Here are some benchmark results comparing Albucore with OpenCV and Numpy:
+
+For more detailed benchmark results, including other configurations and data types, refer to the [Benchmark.md](Benchmark.md) in the repository.
+
+## License
+
+Distributed under the MIT License. See LICENSE for more information.

albucore-0.0.1/README.md

@@ -0,0 +1,61 @@
+# Albucore
+
+Albucore is a high-performance image processing library designed to optimize operations on images using Python and OpenCV, building upon the foundations laid by the popular Albumentations library. It offers specialized optimizations for different image data types and aims to provide faster processing times through efficient algorithm implementations.
+
+## Features
+
+- Optimized image multiplication operations for both `uint8` and `float32` data types.
+- Support for single-channel and multi-channel images.
+- Custom decorators to manage channel dimensions and output constraints.
+
+## Installation
+
+Install Albucore using pip:
+
+```bash
+pip install -U albucore
+```
+
+## Example
+
+Here's how you can use Albucore to multiply an image by a constant or a vector:
+
+```python
+import cv2
+import numpy as np
+from albucore import multiply
+
+# Load an image
+img = cv2.imread('path_to_your_image.jpg')
+
+# Multiply by a constant
+multiplied_image = multiply(img, 1.5)
+
+# Multiply by a vector
+multiplier = [1.5, 1.2, 0.9]  # Different multiplier for each channel
+multiplied_image = multiply(img, multiplier)
+```
+
+## Benchmarks
+
+### Benchmark Results for 1000 Images of `float32` Type (256, 256, 1)
+
+|                  | albucore     | opencv           | numpy            |
+| ---------------- | ------------ | ---------------- | ---------------- |
+| MultiplyConstant | 12925 ± 1237 | 10963 ± 1053     | **14040 ± 2063** |
+| MultiplyVector   | 3832 ± 512   | **10824 ± 1005** | 8986 ± 511       |
+
+### Benchmark Results for 1000 Images of `uint8` Type (256, 256, 1)
+
+|                  | albucore         | opencv      | numpy      |
+| ---------------- | ---------------- | ----------- | ---------- |
+| MultiplyConstant | **24131 ± 1129** | 11622 ± 175 | 6969 ± 643 |
+| MultiplyVector   | **24279 ± 908**  | 11756 ± 152 | 6936 ± 408 |
+
+Albucore provides significant performance improvements for image processing tasks. Here are some benchmark results comparing Albucore with OpenCV and Numpy:
+
+For more detailed benchmark results, including other configurations and data types, refer to the [Benchmark.md](Benchmark.md) in the repository.
+
+## License
+
+Distributed under the MIT License. See LICENSE for more information.

albucore-0.0.1/albucore/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.0.1"
+
+from .functions import *

albucore-0.0.1/albucore/functions.py

@@ -0,0 +1,58 @@
+from typing import Sequence, Union
+
+import cv2
+import numpy as np
+
+from albucore.utils import (
+    MAX_VALUES_BY_DTYPE,
+    clip,
+    clipped,
+    is_grayscale_image,
+    maybe_process_in_chunks,
+    preserve_channel_dim,
+)
+
+
+@clipped
+def _multiply_non_uint8_optimized(img: np.ndarray, multiplier: Union[Sequence[float], float]) -> np.ndarray:
+    img = img.astype(np.float32)
+    return np.multiply(img, multiplier)
+
+
+@preserve_channel_dim
+def _multiply_uint8_optimized(img: np.ndarray, multiplier: Union[Sequence[float], float]) -> np.ndarray:
+    max_value = MAX_VALUES_BY_DTYPE[np.uint8]
+    if isinstance(multiplier, float):
+        lut = np.arange(0, max_value + 1, dtype=np.float32)
+        lut *= multiplier
+        lut = clip(lut, np.uint8)
+        func = maybe_process_in_chunks(cv2.LUT, lut=lut)
+        return func(img)
+
+    if is_grayscale_image(img):
+        multiplier = multiplier[0]
+        lut = np.arange(0, max_value + 1, dtype=np.float32)
+        lut *= multiplier
+        lut = clip(lut, np.uint8)
+        func = maybe_process_in_chunks(cv2.LUT, lut=lut)
+        return func(img)
+
+    num_channels = img.shape[-1]
+    lut = [np.arange(0, max_value + 1, dtype=np.float32)] * num_channels
+    lut = np.stack(lut, axis=-1)
+
+    lut *= multiplier
+    lut = clip(lut, np.uint8)
+
+    images = []
+    for i in range(num_channels):
+        func = maybe_process_in_chunks(cv2.LUT, lut=lut[:, i])
+        images.append(func(img[:, :, i]))
+    return np.stack(images, axis=-1)
+
+
+def multiply(img: np.ndarray, multiplier: Union[Sequence[float], float]) -> np.ndarray:
+    if img.dtype == np.uint8:
+        return _multiply_uint8_optimized(img, multiplier)
+
+    return _multiply_non_uint8_optimized(img, multiplier)

albucore-0.0.1/albucore/utils.py

@@ -0,0 +1,119 @@
+from functools import wraps
+from typing import Any, Callable
+
+import cv2
+import numpy as np
+from typing_extensions import Concatenate, ParamSpec
+
+MONO_CHANNEL_DIMENSIONS = 2
+NUM_MULTI_CHANNEL_DIMENSIONS = 3
+FOUR = 4
+TWO = 2
+
+P = ParamSpec("P")
+
+MAX_VALUES_BY_DTYPE = {
+    np.dtype("uint8"): 255,
+    np.dtype("uint16"): 65535,
+    np.dtype("uint32"): 4294967295,
+    np.dtype("float32"): 1.0,
+    np.uint8: 255,
+    np.uint16: 65535,
+    np.uint32: 4294967295,
+    np.float32: 1.0,
+}
+
+NPDTYPE_TO_OPENCV_DTYPE = {
+    np.uint8: cv2.CV_8U,
+    np.uint16: cv2.CV_16U,
+    np.int32: cv2.CV_32S,
+    np.float32: cv2.CV_32F,
+    np.float64: cv2.CV_64F,
+    np.dtype("uint8"): cv2.CV_8U,
+    np.dtype("uint16"): cv2.CV_16U,
+    np.dtype("int32"): cv2.CV_32S,
+    np.dtype("float32"): cv2.CV_32F,
+    np.dtype("float64"): cv2.CV_64F,
+}
+
+
+def maybe_process_in_chunks(
+    process_fn: Callable[Concatenate[np.ndarray, P], np.ndarray], **kwargs: Any
+) -> Callable[[np.ndarray], np.ndarray]:
+    """Wrap OpenCV function to enable processing images with more than 4 channels.
+
+    Limitations:
+        This wrapper requires image to be the first argument and rest must be sent via named arguments.
+
+    Args:
+        process_fn: Transform function (e.g cv2.resize).
+        kwargs: Additional parameters.
+
+    Returns:
+        np.ndarray: Transformed image.
+
+    """
+
+    @wraps(process_fn)
+    def __process_fn(img: np.ndarray) -> np.ndarray:
+        num_channels = get_num_channels(img)
+        if num_channels > FOUR:
+            chunks = []
+            for index in range(0, num_channels, 4):
+                if num_channels - index == TWO:
+                    # Many OpenCV functions cannot work with 2-channel images
+                    for i in range(2):
+                        chunk = img[:, :, index + i : index + i + 1]
+                        chunk = process_fn(chunk, **kwargs)
+                        chunk = np.expand_dims(chunk, -1)
+                        chunks.append(chunk)
+                else:
+                    chunk = img[:, :, index : index + 4]
+                    chunk = process_fn(chunk, **kwargs)
+                    chunks.append(chunk)
+            return np.dstack(chunks)
+
+        return process_fn(img, **kwargs)
+
+    return __process_fn
+
+
+def clip(img: np.ndarray, dtype: Any) -> np.ndarray:
+    max_value = MAX_VALUES_BY_DTYPE[dtype]
+    return np.clip(img, 0, max_value).astype(dtype)
+
+
+def clipped(func: Callable[Concatenate[np.ndarray, P], np.ndarray]) -> Callable[Concatenate[np.ndarray, P], np.ndarray]:
+    @wraps(func)
+    def wrapped_function(img: np.ndarray, *args: P.args, **kwargs: P.kwargs) -> np.ndarray:
+        dtype = img.dtype
+        return clip(func(img, *args, **kwargs), dtype)
+
+    return wrapped_function
+
+
+def get_num_channels(image: np.ndarray) -> int:
+    return image.shape[2] if image.ndim == NUM_MULTI_CHANNEL_DIMENSIONS else 1
+
+
+def preserve_channel_dim(
+    func: Callable[Concatenate[np.ndarray, P], np.ndarray],
+) -> Callable[Concatenate[np.ndarray, P], np.ndarray]:
+    """Preserve dummy channel dim."""
+
+    @wraps(func)
+    def wrapped_function(img: np.ndarray, *args: P.args, **kwargs: P.kwargs) -> np.ndarray:
+        shape = img.shape
+        result = func(img, *args, **kwargs)
+        if len(shape) == NUM_MULTI_CHANNEL_DIMENSIONS and shape[-1] == 1 and result.ndim == MONO_CHANNEL_DIMENSIONS:
+            return np.expand_dims(result, axis=-1)
+
+        if len(shape) == MONO_CHANNEL_DIMENSIONS and result.ndim == NUM_MULTI_CHANNEL_DIMENSIONS:
+            return result[:, :, 0]
+        return result
+
+    return wrapped_function
+
+
+def is_grayscale_image(image: np.ndarray) -> bool:
+    return get_num_channels(image) == 1

albucore-0.0.1/albucore.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.1
+Name: albucore
+Version: 0.0.1
+Summary: A high-performance image processing library designed to optimize and extend the Albumentations library with specialized functions for advanced image transformations. Perfect for developers working in computer vision who require efficient and scalable image augmentation.
+Home-page: https://github.com/albumentations-team/albucore
+Author: Vladimir I. Iglovikov
+License: MIT
+Keywords: Image Processing,Computer Vision,Image Augmentation,Albumentations,Optimization,Machine Learning,Deep Learning,Python Imaging,Data Augmentation,Performance,Efficiency,High-Performance,CV,OpenCV,Automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.4
+Requires-Dist: tomli>=2.0.1
+Requires-Dist: opencv-python-headless>=4.9.0
+
+# Albucore
+
+Albucore is a high-performance image processing library designed to optimize operations on images using Python and OpenCV, building upon the foundations laid by the popular Albumentations library. It offers specialized optimizations for different image data types and aims to provide faster processing times through efficient algorithm implementations.
+
+## Features
+
+- Optimized image multiplication operations for both `uint8` and `float32` data types.
+- Support for single-channel and multi-channel images.
+- Custom decorators to manage channel dimensions and output constraints.
+
+## Installation
+
+Install Albucore using pip:
+
+```bash
+pip install -U albucore
+```
+
+## Example
+
+Here's how you can use Albucore to multiply an image by a constant or a vector:
+
+```python
+import cv2
+import numpy as np
+from albucore import multiply
+
+# Load an image
+img = cv2.imread('path_to_your_image.jpg')
+
+# Multiply by a constant
+multiplied_image = multiply(img, 1.5)
+
+# Multiply by a vector
+multiplier = [1.5, 1.2, 0.9]  # Different multiplier for each channel
+multiplied_image = multiply(img, multiplier)
+```
+
+## Benchmarks
+
+### Benchmark Results for 1000 Images of `float32` Type (256, 256, 1)
+
+|                  | albucore     | opencv           | numpy            |
+| ---------------- | ------------ | ---------------- | ---------------- |
+| MultiplyConstant | 12925 ± 1237 | 10963 ± 1053     | **14040 ± 2063** |
+| MultiplyVector   | 3832 ± 512   | **10824 ± 1005** | 8986 ± 511       |
+
+### Benchmark Results for 1000 Images of `uint8` Type (256, 256, 1)
+
+|                  | albucore         | opencv      | numpy      |
+| ---------------- | ---------------- | ----------- | ---------- |
+| MultiplyConstant | **24131 ± 1129** | 11622 ± 175 | 6969 ± 643 |
+| MultiplyVector   | **24279 ± 908**  | 11756 ± 152 | 6936 ± 408 |
+
+Albucore provides significant performance improvements for image processing tasks. Here are some benchmark results comparing Albucore with OpenCV and Numpy:
+
+For more detailed benchmark results, including other configurations and data types, refer to the [Benchmark.md](Benchmark.md) in the repository.
+
+## License
+
+Distributed under the MIT License. See LICENSE for more information.

albucore-0.0.1/albucore.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+albucore/__init__.py
+albucore/functions.py
+albucore/utils.py
+albucore.egg-info/PKG-INFO
+albucore.egg-info/SOURCES.txt
+albucore.egg-info/dependency_links.txt
+albucore.egg-info/not-zip-safe
+albucore.egg-info/requires.txt
+albucore.egg-info/top_level.txt
+tests/test_functions.py

albucore-0.0.1/albucore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

albucore-0.0.1/albucore.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

albucore-0.0.1/albucore.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.24.4
+tomli>=2.0.1
+opencv-python-headless>=4.9.0

albucore-0.0.1/albucore.egg-info/top_level.txt

@@ -0,0 +1 @@
+albucore

albucore-0.0.1/pyproject.toml

@@ -0,0 +1,176 @@
+# NOTE: you have to use single-quoted strings in TOML for regular expressions.
+# It's the equivalent of r-strings in Python.  Multiline strings are treated as
+# verbose regular expressions by Black.  Use [ ] to denote a significant space
+# character.
+
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [
+  "setuptools",
+  "wheel",
+]
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+  ".bzr",
+  ".direnv",
+  ".eggs",
+  ".git",
+  ".git-rewrite",
+  ".hg",
+  ".ipynb_checkpoints",
+  ".mypy_cache",
+  ".nox",
+  ".pants.d",
+  ".pyenv",
+  ".pytest_cache",
+  ".pytype",
+  ".ruff_cache",
+  ".svn",
+  ".tox",
+  ".venv",
+  ".vscode",
+  "__pypackages__",
+  "_build",
+  "buck-out",
+  "build",
+  "dist",
+  "node_modules",
+  "site-packages",
+  "venv",
+  "tests",
+  "setup.py",
+  "tools",
+  "site",
+]
+
+line-length = 120
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py38"
+
+[tool.ruff.lint]
+explicit-preview-rules = true
+
+select = [
+  "F",
+  "E",
+  "W",
+  "C90",
+  "I",
+  "N",
+  "D",
+  "UP",
+  "YTT",
+  "ANN",
+  "ASYNC",
+  "TRIO",
+  "S",
+  "BLE",
+  "FBT",
+  "B",
+  "A",
+  "COM",
+  "CPY",
+  "C4",
+  "DTZ",
+  "T10",
+  "DJ",
+  "EM",
+  "EXE",
+  "ISC",
+  "ICN",
+  "G",
+  "INP",
+  "PIE",
+  "T20",
+  "PYI",
+  "PT",
+  "Q",
+  "RSE",
+  "RET",
+  "SLF",
+  "SLOT",
+  "SIM",
+  "TID",
+  "TCH",
+  "INT",
+  "ARG",
+  "PTH",
+  "TD",
+  "FIX",
+  "ERA",
+  "PD",
+  "PGH",
+  "PL",
+  "TRY",
+  "FLY",
+  "NPY",
+  "PERF",
+  "FURB",
+  "LOG",
+  "RUF",
+]
+ignore = [
+  "D104",
+  "F403",
+  "D100",
+  "D103",
+  "ANN401",
+  "D101",
+  "D107",
+  "ANN101",
+  "D105",
+  "D102",
+  "PD901",
+  "FBT001",
+  "EM101",
+  "TRY003",
+  "T201",
+  "B023",
+  "PERF203",
+  "FBT002",
+  "BLE001",
+  "COM812",
+]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = [
+  "ALL",
+]
+unfixable = [
+]
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_version = "3.8"
+ignore_missing_imports = true
+follow_imports = "silent"
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+check_untyped_defs = true
+no_implicit_reexport = true
+
+# for strict mypy: (this is the tricky one :-))
+disallow_untyped_defs = true

albucore-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

albucore-0.0.1/setup.py

@@ -0,0 +1,89 @@
+import re
+from pathlib import Path
+from typing import List, Tuple
+
+from pkg_resources import DistributionNotFound, get_distribution
+from setuptools import find_packages, setup
+
+INSTALL_REQUIRES = [
+    "numpy>=1.24.4",
+    "tomli>=2.0.1",
+]
+
+CHOOSE_INSTALL_REQUIRES = [
+    (
+        ("opencv-python>=4.9.0", "opencv-contrib-python>=4.9.0", "opencv-contrib-python-headless>=4.9.0"),
+        "opencv-python-headless>=4.9.0",
+    ),
+]
+
+def get_version() -> str:
+    current_dir = Path(__file__).parent
+    version_file = current_dir / "albucore" / "__init__.py"
+    with open(version_file, encoding="utf-8") as f:
+        version_match = re.search(r'^__version__ = [\'"]([^\'"]*)[\'"]', f.read(), re.M)
+        if version_match:
+            return version_match.group(1)
+    raise RuntimeError("Unable to find version string.")
+
+def get_long_description() -> str:
+    base_dir = Path(__file__).parent
+    with open(base_dir / "README.md", encoding="utf-8") as f:
+        return f.read()
+
+def choose_requirement(mains: Tuple[str, ...], secondary: str) -> str:
+    for main in mains:
+        try:
+            # Extract the package name from the requirement string
+            package_name = re.split(r"[!<>=]", main)[0]
+            # Check if the package is already installed
+            get_distribution(package_name)
+            return main
+        except DistributionNotFound:
+            continue
+    return secondary
+
+
+def get_install_requirements(install_requires: List[str], choose_install_requires: List[Tuple[Tuple[str, ...], str]]) -> List[str]:
+    for mains, secondary in choose_install_requires:
+        install_requires.append(choose_requirement(mains, secondary))
+    return install_requires
+
+setup(
+    name="albucore",
+    version=get_version(),
+    description='A high-performance image processing library designed to optimize and extend the Albumentations library with specialized functions for advanced image transformations. Perfect for developers working in computer vision who require efficient and scalable image augmentation.',
+    long_description=get_long_description(),
+    long_description_content_type="text/markdown",
+    author="Vladimir I. Iglovikov",
+    license="MIT",
+    url="https://github.com/albumentations-team/albucore",
+    packages=find_packages(exclude=["tests", "benchmark", ".github"]),
+    python_requires=">=3.8",
+    install_requires=get_install_requirements(INSTALL_REQUIRES, CHOOSE_INSTALL_REQUIRES),
+    classifiers=[
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Image Processing",
+    "Typing :: Typed"
+    ],
+    keywords=[
+        "Image Processing", "Computer Vision", "Image Augmentation", "Albumentations", "Optimization", "Machine Learning",
+        "Deep Learning", "Python Imaging", "Data Augmentation", "Performance", "Efficiency", "High-Performance",
+        "CV", "OpenCV", "Automation"
+    ],
+    zip_safe=False
+)

albucore-0.0.1/tests/test_functions.py

@@ -0,0 +1,38 @@
+import numpy as np
+import pytest
+import cv2
+from albucore.utils import MAX_VALUES_BY_DTYPE, clip
+import albucore
+
+# Pre-defined images for testing
+UINT8_IMAGE = np.random.randint(0, 255, (3, 3, 3), dtype=np.uint8)
+FLOAT32_IMAGE = np.random.random((3, 3, 3)).astype(np.float32)
+
+# Test data combining both scalar and vector multipliers
+test_data = [
+    (UINT8_IMAGE, 1.5),
+    (FLOAT32_IMAGE, 1.5),
+    (UINT8_IMAGE, np.array([1.5, 0.75, 1.1], dtype=np.float32)),
+    (FLOAT32_IMAGE, np.array([1.5, 0.75, 1.1], dtype=np.float32))
+]
+
+@pytest.mark.parametrize("image, multiplier", test_data)
+def test_multiply(image, multiplier):
+    max_value = MAX_VALUES_BY_DTYPE[image.dtype]
+
+    result = albucore.multiply(image, multiplier)
+
+    numpy_result = image * multiplier
+    numpy_result = np.clip(0, max_value, numpy_result).astype(image.dtype)
+
+    # Check that all results match expected dtype and value arrays
+    assert result.dtype == image.dtype, "Result dtype does not match expected dtype."
+    assert np.array_equal(result, numpy_result), "Result does not match NumPy result."
+
+@pytest.mark.parametrize("input_img, dtype, expected", [
+    (np.array([[-300, 0], [100, 400]], dtype=np.float32), np.uint8, np.array([[0, 0], [100, 255]], dtype=np.float32)),
+    (np.array([[-0.02, 0], [0.5, 2.2]], dtype=np.float32), np.float32, np.array([[0, 0], [0.5, 1.0]], dtype=np.float32))
+])
+def test_clip(input_img, dtype, expected):
+    clipped = clip(input_img, dtype=dtype)
+    assert np.array_equal(clipped, expected)