normal-grain-merge 0.0.0__tar.gz → 0.0.2__tar.gz

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/PKG-INFO

@@ -1,78 +1,108 @@
-Metadata-Version: 2.4
-Name: normal_grain_merge
-Version: 0.0.0
-Summary: Fused normal and grain merge C extension
-Author: Samuel Howard
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/samhaswon/normal_grain_merge
-Project-URL: Bug Tracker, https://github.com/samhaswon/normal_grain_merge/issues
-Keywords: image,processing
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: C
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy<2.3.0
-Dynamic: license-file
-
-# normal_grain_merge
-
-This implements a combined version of the blend modes normal and grain merge.
-Grain merge is performed on *s* and *t* with the result normal-merged with *b*.
-Subscripts indicate channels, with alpha (α) channels broadcast to three channels.
-
-$$
-(((\mathrm{t_{rgb}} + \mathrm{s_{rgb}} - 0.5) * \mathrm{t_\alpha} + \mathrm{t_{rgb}} * (1 - \mathrm{t_\alpha})) * (1 - 0.3) + \mathrm{s_{rgb}} * 0.3) * \mathrm{t_\alpha} + \mathrm{b_{rgb}} * (1 - \mathrm{t_\alpha})
-$$
-
-## Usage
-```py
-import numpy as np
-from normal_grain_merge import normal_grain_merge, KernelKind
-
-
-# Example arrays
-base = np.zeros((100, 100, 3), dtype=np.uint8)
-texture = np.zeros((100, 100, 3), dtype=np.uint8)
-skin = np.zeros((100, 100, 4), dtype=np.uint8)
-im_alpha = np.zeros((100, 100), dtype=np.uint8)
-
-result_scalar = normal_grain_merge(base, texture, skin, im_alpha, KernelKind.KERNEL_SCALAR.value)
-print(result_scalar.shape, result_scalar.dtype)
-```
-
-There are three kernels implemented in this module as defined in `KernelKind`.
-
-- `KERNEL_AUTO`: Automatically chooses the kernel, preferring AVX2
-- `KERNEL_SCALAR`: Portable scalar implementation.
-- `KERNEL_SSE42`: SSE4.2 intrinsics kernel. Likely better on AMD CPUs.
-- `KERNEL_AVX2`: AVX2 intrinsics kernel. Likely better on Intel CPUs.
-
-### Parameters
-
-All input matrices should have the same height and width.
-
-#### `base`
-
-RGB or RGBA, dropping the alpha channel if it exists.
-The base image for application.
-
-#### `texture`
-
-RGB or RGBA, applying the alpha if it exists.
-This is the texture to be applied.
-
-#### `skin`
-
-RGBA, the segmented portion of base to texture.
-The "skin" of the object the texture is to be applied to.
-
-#### `im_alpha`
-
-The alpha of parameter `skin`. 
-This is mostly a holdover from the Python implementation to deal with NumPy.
-
-#### `kernel`
-
-One of `KernelKind`.
+Metadata-Version: 2.4
+Name: normal_grain_merge
+Version: 0.0.2
+Summary: Fused normal and grain merge C extension
+Author: Samuel Howard
+License: MIT
+Project-URL: Homepage, https://github.com/samhaswon/normal_grain_merge
+Project-URL: Bug Tracker, https://github.com/samhaswon/normal_grain_merge/issues
+Keywords: image,processing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.3.0
+Dynamic: license-file
+
+# normal_grain_merge
+
+This implements a combined version of the blend modes normal and grain merge.
+Grain merge is performed on *s* and *t* with the result normal-merged with *b*.
+Subscripts indicate channels, with alpha (α) channels broadcast to three channels.
+
+$$
+(((\mathrm{t_{rgb}} + \mathrm{s_{rgb}} - 0.5) * \mathrm{t_\alpha} + \mathrm{t_{rgb}} * (1 - \mathrm{t_\alpha})) * (1 - 0.3) + \mathrm{s_{rgb}} * 0.3) * \mathrm{t_\alpha} + \mathrm{b_{rgb}} * (1 - \mathrm{t_\alpha})
+$$
+
+## Installation
+
+```shell
+pip install normal-grain-merge
+```
+
+## Usage
+```py
+import numpy as np
+from normal_grain_merge import normal_grain_merge, KernelKind
+
+
+# Example arrays
+base = np.zeros((100, 100, 3), dtype=np.uint8)
+texture = np.zeros((100, 100, 3), dtype=np.uint8)
+skin = np.zeros((100, 100, 4), dtype=np.uint8)
+im_alpha = np.zeros((100, 100), dtype=np.uint8)
+
+result_scalar = normal_grain_merge(base, texture, skin, im_alpha, KernelKind.KERNEL_SCALAR.value)
+print(result_scalar.shape, result_scalar.dtype)
+```
+
+There are three kernels implemented in this module as defined in `KernelKind`.
+
+- `KERNEL_AUTO`: Automatically chooses the kernel, preferring AVX2
+- `KERNEL_SCALAR`: Portable scalar implementation.
+- `KERNEL_SSE42`: SSE4.2 intrinsics kernel. Likely better on AMD CPUs.
+- `KERNEL_AVX2`: AVX2 intrinsics kernel. Likely better on Intel CPUs.
+
+### Parameters
+
+All input matrices should have the same height and width.
+
+#### `base`
+
+RGB or RGBA, dropping the alpha channel if it exists.
+The base image for application.
+
+#### `texture`
+
+RGB or RGBA, applying the alpha if it exists.
+This is the texture to be applied.
+
+#### `skin`
+
+RGBA, the segmented portion of base to texture.
+The "skin" of the object the texture is to be applied to.
+
+#### `im_alpha`
+
+The alpha of parameter `skin`. 
+This is mostly a holdover from the Python implementation to deal with NumPy.
+
+#### `kernel`
+
+One of `KernelKind`.
+
+## Performance
+
+The entire reason for me writing this was NumPy being slow when this operation is in the hot path.
+So, I decided to write a SIMD version that does the type casting outside NumPy with only the intermediate values being in FP32.
+
+How much of a speedup is this? All numbers are from a Ryzen 7 4800H running Windows 11 and Python 3.12.4.
+
+| Method/Kernel     | Average Iteration Time |
+|-------------------|------------------------|
+| C scalar kernel   | 0.019565s              |
+| C SSE4.2 kernel   | 0.013705s              |
+| C AVX2 kernel     | 0.016842s              |
+| NumPy version     | 0.228098s              |
+| Old NumPy version | 0.350554s              |
+
+| Method Comparison  | Speedup  |
+|--------------------|----------|
+| NumPy -> scalar    | 91.4227% |
+| NumPy -> SSE4.2    | 93.9915% |
+| NumPy -> AVX2      | 92.6165% |
+| Old np -> SSE4.2   | 96.0904% |
+| C scalar -> SSE4.2 | 29.9487% |
+| C scalar -> AVX2   | 13.9183% |

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/README.md

@@ -8,6 +8,12 @@ $$
 (((\mathrm{t_{rgb}} + \mathrm{s_{rgb}} - 0.5) * \mathrm{t_\alpha} + \mathrm{t_{rgb}} * (1 - \mathrm{t_\alpha})) * (1 - 0.3) + \mathrm{s_{rgb}} * 0.3) * \mathrm{t_\alpha} + \mathrm{b_{rgb}} * (1 - \mathrm{t_\alpha})
 $$
 
+## Installation
+
+```shell
+pip install normal-grain-merge
+```
+
 ## Usage
 ```py
 import numpy as np
@@ -58,3 +64,27 @@ This is mostly a holdover from the Python implementation to deal with NumPy.
 #### `kernel`
 
 One of `KernelKind`.
+
+## Performance
+
+The entire reason for me writing this was NumPy being slow when this operation is in the hot path.
+So, I decided to write a SIMD version that does the type casting outside NumPy with only the intermediate values being in FP32.
+
+How much of a speedup is this? All numbers are from a Ryzen 7 4800H running Windows 11 and Python 3.12.4.
+
+| Method/Kernel     | Average Iteration Time |
+|-------------------|------------------------|
+| C scalar kernel   | 0.019565s              |
+| C SSE4.2 kernel   | 0.013705s              |
+| C AVX2 kernel     | 0.016842s              |
+| NumPy version     | 0.228098s              |
+| Old NumPy version | 0.350554s              |
+
+| Method Comparison  | Speedup  |
+|--------------------|----------|
+| NumPy -> scalar    | 91.4227% |
+| NumPy -> SSE4.2    | 93.9915% |
+| NumPy -> AVX2      | 92.6165% |
+| Old np -> SSE4.2   | 96.0904% |
+| C scalar -> SSE4.2 | 29.9487% |
+| C scalar -> AVX2   | 13.9183% |

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/normal_grain_merge/normal_grain_merge.pyi

@@ -1,28 +1,28 @@
-# ngm/normal_grain_merge.pyi
-from typing import Literal
-import numpy as np
-from .kernel_kind import KernelKind
-
-def normal_grain_merge(
-    base: np.ndarray,
-    texture: np.ndarray,
-    skin: np.ndarray,
-    im_alpha: np.ndarray,
-    kernel: Literal["auto", "scalar", "sse42", "avx2"] | KernelKind = "auto",
-) -> np.ndarray:
-    """
-    Performs a combined merge: grain merge of skin and texture,
-    then a normal merge of that result on base.
-    Channel ordering doesn't matter as long as it is consistent.
-    :param base: The base RGB image.
-    :param texture: The texture, either RGB or RGBA.
-    :param skin: The RGBA skin cutout.
-    :param im_alpha: The alpha from the cutout.
-    :param kernel: Which kernel to use.
-    The `auto` kernel chooses between avx2 and sse4.2 when compiled with gcc and uses `scaler` on Windows.
-    The `scalar` kernel is a portable implementation that relies on the compiler for SIMD.
-    The `sse42` kernel uses SSE4.2 intrinsics.
-    The `avx2` kernel uses AVX2 intrinsics.
-    :return: RGB np.ndarray.
-    """
-    ...
+# ngm/normal_grain_merge.pyi
+from typing import Literal
+import numpy as np
+from .kernel_kind import KernelKind
+
+def normal_grain_merge(
+    base: np.ndarray,
+    texture: np.ndarray,
+    skin: np.ndarray,
+    im_alpha: np.ndarray,
+    kernel: Literal["auto", "scalar", "sse42", "avx2"] | KernelKind = "auto",
+) -> np.ndarray:
+    """
+    Performs a combined merge: grain merge of skin and texture,
+    then a normal merge of that result on base.
+    Channel ordering doesn't matter as long as it is consistent.
+    :param base: The base RGB image.
+    :param texture: The texture, either RGB or RGBA.
+    :param skin: The RGBA skin cutout.
+    :param im_alpha: The alpha from the cutout.
+    :param kernel: Which kernel to use.
+    The `auto` kernel chooses between avx2 and sse4.2 when compiled with gcc and uses `scaler` on Windows.
+    The `scalar` kernel is a portable implementation that relies on the compiler for SIMD.
+    The `sse42` kernel uses SSE4.2 intrinsics.
+    The `avx2` kernel uses AVX2 intrinsics.
+    :return: RGB np.ndarray.
+    """
+    ...

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/normal_grain_merge.egg-info/PKG-INFO

@@ -1,78 +1,108 @@
-Metadata-Version: 2.4
-Name: normal_grain_merge
-Version: 0.0.0
-Summary: Fused normal and grain merge C extension
-Author: Samuel Howard
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/samhaswon/normal_grain_merge
-Project-URL: Bug Tracker, https://github.com/samhaswon/normal_grain_merge/issues
-Keywords: image,processing
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: C
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy<2.3.0
-Dynamic: license-file
-
-# normal_grain_merge
-
-This implements a combined version of the blend modes normal and grain merge.
-Grain merge is performed on *s* and *t* with the result normal-merged with *b*.
-Subscripts indicate channels, with alpha (α) channels broadcast to three channels.
-
-$$
-(((\mathrm{t_{rgb}} + \mathrm{s_{rgb}} - 0.5) * \mathrm{t_\alpha} + \mathrm{t_{rgb}} * (1 - \mathrm{t_\alpha})) * (1 - 0.3) + \mathrm{s_{rgb}} * 0.3) * \mathrm{t_\alpha} + \mathrm{b_{rgb}} * (1 - \mathrm{t_\alpha})
-$$
-
-## Usage
-```py
-import numpy as np
-from normal_grain_merge import normal_grain_merge, KernelKind
-
-
-# Example arrays
-base = np.zeros((100, 100, 3), dtype=np.uint8)
-texture = np.zeros((100, 100, 3), dtype=np.uint8)
-skin = np.zeros((100, 100, 4), dtype=np.uint8)
-im_alpha = np.zeros((100, 100), dtype=np.uint8)
-
-result_scalar = normal_grain_merge(base, texture, skin, im_alpha, KernelKind.KERNEL_SCALAR.value)
-print(result_scalar.shape, result_scalar.dtype)
-```
-
-There are three kernels implemented in this module as defined in `KernelKind`.
-
-- `KERNEL_AUTO`: Automatically chooses the kernel, preferring AVX2
-- `KERNEL_SCALAR`: Portable scalar implementation.
-- `KERNEL_SSE42`: SSE4.2 intrinsics kernel. Likely better on AMD CPUs.
-- `KERNEL_AVX2`: AVX2 intrinsics kernel. Likely better on Intel CPUs.
-
-### Parameters
-
-All input matrices should have the same height and width.
-
-#### `base`
-
-RGB or RGBA, dropping the alpha channel if it exists.
-The base image for application.
-
-#### `texture`
-
-RGB or RGBA, applying the alpha if it exists.
-This is the texture to be applied.
-
-#### `skin`
-
-RGBA, the segmented portion of base to texture.
-The "skin" of the object the texture is to be applied to.
-
-#### `im_alpha`
-
-The alpha of parameter `skin`. 
-This is mostly a holdover from the Python implementation to deal with NumPy.
-
-#### `kernel`
-
-One of `KernelKind`.
+Metadata-Version: 2.4
+Name: normal_grain_merge
+Version: 0.0.2
+Summary: Fused normal and grain merge C extension
+Author: Samuel Howard
+License: MIT
+Project-URL: Homepage, https://github.com/samhaswon/normal_grain_merge
+Project-URL: Bug Tracker, https://github.com/samhaswon/normal_grain_merge/issues
+Keywords: image,processing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.3.0
+Dynamic: license-file
+
+# normal_grain_merge
+
+This implements a combined version of the blend modes normal and grain merge.
+Grain merge is performed on *s* and *t* with the result normal-merged with *b*.
+Subscripts indicate channels, with alpha (α) channels broadcast to three channels.
+
+$$
+(((\mathrm{t_{rgb}} + \mathrm{s_{rgb}} - 0.5) * \mathrm{t_\alpha} + \mathrm{t_{rgb}} * (1 - \mathrm{t_\alpha})) * (1 - 0.3) + \mathrm{s_{rgb}} * 0.3) * \mathrm{t_\alpha} + \mathrm{b_{rgb}} * (1 - \mathrm{t_\alpha})
+$$
+
+## Installation
+
+```shell
+pip install normal-grain-merge
+```
+
+## Usage
+```py
+import numpy as np
+from normal_grain_merge import normal_grain_merge, KernelKind
+
+
+# Example arrays
+base = np.zeros((100, 100, 3), dtype=np.uint8)
+texture = np.zeros((100, 100, 3), dtype=np.uint8)
+skin = np.zeros((100, 100, 4), dtype=np.uint8)
+im_alpha = np.zeros((100, 100), dtype=np.uint8)
+
+result_scalar = normal_grain_merge(base, texture, skin, im_alpha, KernelKind.KERNEL_SCALAR.value)
+print(result_scalar.shape, result_scalar.dtype)
+```
+
+There are three kernels implemented in this module as defined in `KernelKind`.
+
+- `KERNEL_AUTO`: Automatically chooses the kernel, preferring AVX2
+- `KERNEL_SCALAR`: Portable scalar implementation.
+- `KERNEL_SSE42`: SSE4.2 intrinsics kernel. Likely better on AMD CPUs.
+- `KERNEL_AVX2`: AVX2 intrinsics kernel. Likely better on Intel CPUs.
+
+### Parameters
+
+All input matrices should have the same height and width.
+
+#### `base`
+
+RGB or RGBA, dropping the alpha channel if it exists.
+The base image for application.
+
+#### `texture`
+
+RGB or RGBA, applying the alpha if it exists.
+This is the texture to be applied.
+
+#### `skin`
+
+RGBA, the segmented portion of base to texture.
+The "skin" of the object the texture is to be applied to.
+
+#### `im_alpha`
+
+The alpha of parameter `skin`. 
+This is mostly a holdover from the Python implementation to deal with NumPy.
+
+#### `kernel`
+
+One of `KernelKind`.
+
+## Performance
+
+The entire reason for me writing this was NumPy being slow when this operation is in the hot path.
+So, I decided to write a SIMD version that does the type casting outside NumPy with only the intermediate values being in FP32.
+
+How much of a speedup is this? All numbers are from a Ryzen 7 4800H running Windows 11 and Python 3.12.4.
+
+| Method/Kernel     | Average Iteration Time |
+|-------------------|------------------------|
+| C scalar kernel   | 0.019565s              |
+| C SSE4.2 kernel   | 0.013705s              |
+| C AVX2 kernel     | 0.016842s              |
+| NumPy version     | 0.228098s              |
+| Old NumPy version | 0.350554s              |
+
+| Method Comparison  | Speedup  |
+|--------------------|----------|
+| NumPy -> scalar    | 91.4227% |
+| NumPy -> SSE4.2    | 93.9915% |
+| NumPy -> AVX2      | 92.6165% |
+| Old np -> SSE4.2   | 96.0904% |
+| C scalar -> SSE4.2 | 29.9487% |
+| C scalar -> AVX2   | 13.9183% |

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/pyproject.toml

@@ -1,31 +1,31 @@
-[build-system]
-requires = [
-    "setuptools>=64",
-    "wheel",
-    "numpy<2.3.0"  # Follows opencv-python (cv2)
-]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "normal_grain_merge"
-version = "0.0.0"
-description = "Fused normal and grain merge C extension"
-readme = "README.md"
-authors = [
-    { name = "Samuel Howard" }
-]
-dependencies = ["numpy<2.3.0"]
-requires-python = ">=3.7"
-license = "MIT"
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "Programming Language :: C",
-    "Operating System :: OS Independent",
-]
-keywords = [
-    "image",
-    "processing"
-]
-[project.urls]
-"Homepage" = "https://github.com/samhaswon/normal_grain_merge"
-"Bug Tracker" = "https://github.com/samhaswon/normal_grain_merge/issues"
+[build-system]
+requires = [
+    "setuptools>=64",
+    "wheel",
+    "numpy<2.3.0"  # Follows opencv-python (cv2)
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "normal_grain_merge"
+version = "0.0.2"
+description = "Fused normal and grain merge C extension"
+readme = "README.md"
+authors = [
+    { name = "Samuel Howard" }
+]
+dependencies = ["numpy<2.3.0"]
+requires-python = ">=3.8"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "image",
+    "processing"
+]
+[project.urls]
+"Homepage" = "https://github.com/samhaswon/normal_grain_merge"
+"Bug Tracker" = "https://github.com/samhaswon/normal_grain_merge/issues"

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/setup.cfg

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

{normal_grain_merge-0.0.0 → normal_grain_merge-0.0.2}/setup.py

@@ -1,14 +1,18 @@
+import platform
 from setuptools import setup, Extension
-import numpy
 import sys
+import numpy
 
-extra_compile_args = []
 
+arch = platform.machine().lower()
 extra_compile_args = []
+
 if sys.platform == "win32":
     extra_compile_args += ["/O2", "/arch:AVX2", "/Qpar"]  # enables AVX/AVX2; SSE4.2 implied
+elif "arm" in arch or "aarch64" in arch:
+    extra_compile_args += ["-O3"]
 else:
-    extra_compile_args += ["-O3", "-march=x86-64-v3", "-mavx2", "-msse4.2"]
+    extra_compile_args += ["-O3", "-march=x86-64", "-mavx2", "-msse4.2"]
 
 module = Extension(
     "normal_grain_merge.normal_grain_merge",
@@ -19,7 +23,7 @@ module = Extension(
 
 setup(
     name="normal_grain_merge",
-    version="0.0.0",
+    version="0.0.2",
     description="Normal grain merge C extension",
     ext_modules=[module],
     packages=["normal_grain_merge"],