mergechannels 0.1.0__tar.gz → 0.1.1__tar.gz

mergechannels-0.1.1/.gitattributes

@@ -0,0 +1,7 @@
+# LFS for image files
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text

{mergechannels-0.1.0 → mergechannels-0.1.1}/Cargo.lock

@@ -59,7 +59,7 @@ dependencies = [
 
 [[package]]
 name = "mergechannels"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "lazy_static",
  "ndarray",

{mergechannels-0.1.0 → mergechannels-0.1.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mergechannels"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

mergechannels-0.1.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: mergechannels
+Version: 0.1.1
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Dist: numpy>=1.24.4
+License-File: LICENSE
+License: MIT
+Requires-Python: >=3.8, <3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+[![CI](https://github.com/zacswider/mergechannels/actions/workflows/CI.yml/badge.svg)](https://github.com/zacswider/mergechannels/actions/workflows/CI.yml)
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![PyPI](https://img.shields.io/pypi/v/mergechannels)
+
+# mergechannels
+
+This project was originally conceived because I often find myself wanting to apply and blend colormaps to images while working from Python, and for historical reasons many of my favorite colormaps are distributed as [FIJI](https://imagej.net/software/fiji/) lookup tables. I also care about things likes speed and memory usage (e.g., not casting large arrays to floating point dtypes, not creating multiple whole arrays just to add them together), so I was interested in seeing if I could at least match matplotlib's colormapping performance with my own hand-rolled colorizer in Rust.
+
+
+
+## Installation
+
+Install pre-compiled binaries from [PyPI](https://pypi.org/project/mergechannels/):
+```bash
+pip install mergechannels
+```
+
+Build from source on your own machine:
+```bash
+pip install git+https://github.com/zacswider/mergechannels.git
+```
+
+## Usage
+*NOTE*: scikit-image is not a dependency of this project, but is used in the examples below to fetch images.
+
+### colorize a single image
+
+```python
+from skimage import data
+import mergechannels as mc
+
+img = data.camera()
+colorized = mc.apply_color_map(img, 'Red/Green')
+fig, axes = plt.subplots(1, 2, figsize=(6, 3), dpi=150)
+for ax in axes: ax.axis('off')
+(a, b) = axes
+a.imshow(img, cmap='gray')
+b.imshow(colorized)
+plt.show()
+print(colorized.shape, colorized.dtype)
+>> (512, 512, 3) uint8
+```
+![colorize a single image](assets/readme_images/camera_red-green.png)
+
+
+### apply a different colormap to each channel
+```python
+from skimage import data
+import matplotlib.pyplot as plt
+import mergechannels as mc
+
+cells, nuclei = data.cells3d().max(axis=0)
+cells = to_uint8(cells)     # normalize your own arrays, mergechannels doesn't currently handle this
+nuclei = to_uint8(nuclei)   # normalize your own arrays, mergechannels doesn't currently handle this
+
+fig, axes = plt.subplots(2, 2, figsize=(6, 6), dpi=150)
+for ax in axes.ravel(): ax.axis('off')
+(a, b, c, d) = axes.ravel()
+a.imshow(cells, cmap='gray')
+b.imshow(nuclei, cmap='gray')
+c.imshow(
+    mc.merge(
+        [cells, nuclei],
+        ['Orange Hot', 'Cyan Hot'],  # maximum blending is the default
+    ),
+)
+d.imshow(
+    mc.merge(
+        [cells, nuclei],
+        ['I Blue', 'I Forest'],
+        blending='min',     # use minimum blending with inverted colormaps
+    ),
+)
+fig.tight_layout()
+plt.show()
+```
+![apply a different colormap to each channel](assets/readme_images/cells_multicolor.png)
+
+
+## Roadmap
+mergechannels is currently incredibly simple. It can apply one or more colormaps to one or more 2D 8-bit images and that's it.
+- Add support for any numerical dtype
+- Add support for 3D images
+- Add option to return any colormap as a matplotlib colormap
+- Add support for directly passing matplotlib colormaps instead of colormap names
+- Parallelize colormap application on large images (if it's helpful)
+- Add option to overlay binary or instance masks onto colorized images
+
+## Acknowledgements
+
+There are other great colormapping libraries available (e.g., [microfilm](https://github.com/guiwitz/microfilm), [cmap](https://github.com/pyapp-kit/cmap)) that are more feature-rich than this one, but which don't address my goals. My hope is that this project can fill an un-met niche and otherwise maintain full compatibility with these and similar libraries.
+
+This project incorporates a number of colormaps that were hand-crafted by Christophe Leterrier and were originally distributed here under the MIT license: https://github.com/cleterrier/ChrisLUTs

mergechannels-0.1.1/README.md

@@ -0,0 +1,93 @@
+[![CI](https://github.com/zacswider/mergechannels/actions/workflows/CI.yml/badge.svg)](https://github.com/zacswider/mergechannels/actions/workflows/CI.yml)
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![PyPI](https://img.shields.io/pypi/v/mergechannels)
+
+# mergechannels
+
+This project was originally conceived because I often find myself wanting to apply and blend colormaps to images while working from Python, and for historical reasons many of my favorite colormaps are distributed as [FIJI](https://imagej.net/software/fiji/) lookup tables. I also care about things likes speed and memory usage (e.g., not casting large arrays to floating point dtypes, not creating multiple whole arrays just to add them together), so I was interested in seeing if I could at least match matplotlib's colormapping performance with my own hand-rolled colorizer in Rust.
+
+
+
+## Installation
+
+Install pre-compiled binaries from [PyPI](https://pypi.org/project/mergechannels/):
+```bash
+pip install mergechannels
+```
+
+Build from source on your own machine:
+```bash
+pip install git+https://github.com/zacswider/mergechannels.git
+```
+
+## Usage
+*NOTE*: scikit-image is not a dependency of this project, but is used in the examples below to fetch images.
+
+### colorize a single image
+
+```python
+from skimage import data
+import mergechannels as mc
+
+img = data.camera()
+colorized = mc.apply_color_map(img, 'Red/Green')
+fig, axes = plt.subplots(1, 2, figsize=(6, 3), dpi=150)
+for ax in axes: ax.axis('off')
+(a, b) = axes
+a.imshow(img, cmap='gray')
+b.imshow(colorized)
+plt.show()
+print(colorized.shape, colorized.dtype)
+>> (512, 512, 3) uint8
+```
+![colorize a single image](assets/readme_images/camera_red-green.png)
+
+
+### apply a different colormap to each channel
+```python
+from skimage import data
+import matplotlib.pyplot as plt
+import mergechannels as mc
+
+cells, nuclei = data.cells3d().max(axis=0)
+cells = to_uint8(cells)     # normalize your own arrays, mergechannels doesn't currently handle this
+nuclei = to_uint8(nuclei)   # normalize your own arrays, mergechannels doesn't currently handle this
+
+fig, axes = plt.subplots(2, 2, figsize=(6, 6), dpi=150)
+for ax in axes.ravel(): ax.axis('off')
+(a, b, c, d) = axes.ravel()
+a.imshow(cells, cmap='gray')
+b.imshow(nuclei, cmap='gray')
+c.imshow(
+    mc.merge(
+        [cells, nuclei],
+        ['Orange Hot', 'Cyan Hot'],  # maximum blending is the default
+    ),
+)
+d.imshow(
+    mc.merge(
+        [cells, nuclei],
+        ['I Blue', 'I Forest'],
+        blending='min',     # use minimum blending with inverted colormaps
+    ),
+)
+fig.tight_layout()
+plt.show()
+```
+![apply a different colormap to each channel](assets/readme_images/cells_multicolor.png)
+
+
+## Roadmap
+mergechannels is currently incredibly simple. It can apply one or more colormaps to one or more 2D 8-bit images and that's it.
+- Add support for any numerical dtype
+- Add support for 3D images
+- Add option to return any colormap as a matplotlib colormap
+- Add support for directly passing matplotlib colormaps instead of colormap names
+- Parallelize colormap application on large images (if it's helpful)
+- Add option to overlay binary or instance masks onto colorized images
+
+## Acknowledgements
+
+There are other great colormapping libraries available (e.g., [microfilm](https://github.com/guiwitz/microfilm), [cmap](https://github.com/pyapp-kit/cmap)) that are more feature-rich than this one, but which don't address my goals. My hope is that this project can fill an un-met niche and otherwise maintain full compatibility with these and similar libraries.
+
+This project incorporates a number of colormaps that were hand-crafted by Christophe Leterrier and were originally distributed here under the MIT license: https://github.com/cleterrier/ChrisLUTs

mergechannels-0.1.1/assets/readme_images/camera_red-green.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1834bf0e964d272de7d6788f2569f5159f6a0180472c27fd77b5e90f34baa45d
+size 563632

mergechannels-0.1.1/assets/readme_images/cells_multicolor.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c02bd422ad5be0c12c62fe6c2776799ffe8c237e0e50af1c10f470ae691100b7
+size 892784

{mergechannels-0.1.0 → mergechannels-0.1.1}/pyproject.toml

@@ -4,11 +4,19 @@ build-backend = "maturin"
 
 [project]
 name = "mergechannels"
+license = { text = "MIT" }
 requires-python = ">=3.8, <3.13"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
+    "License :: OSI Approved :: MIT License",
+    "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",
 ]
 dynamic = ["version"]
 dependencies = ["numpy>=1.24.4"]

{mergechannels-0.1.0 → mergechannels-0.1.1}/python/mergechannels/__init__.pyi

@@ -9,13 +9,19 @@ def merge(
 	arrs: Sequence[np.ndarray],
 	colors: Sequence[COLORMAPS] = (),
 	blending: Literal[BLENDING_OPTIONS] = 'max',
+    saturation_limits: tuple[float, float] = (0.2, 99.8),
 ) -> np.ndarray:
     ...
 
-def apply_color_map(arr: np.ndarray, cmap_name: COLORMAPS) -> np.ndarray: ...
+def apply_color_map(
+    arr: np.ndarray,
+    cmap_name: COLORMAPS,
+    saturation_limits: tuple[float, float] = (0.2, 99.8),
+) -> np.ndarray: ...
 
 def apply_colors_and_merge_nc(
     arrs: Sequence[np.ndarray],
     colors: Sequence[COLORMAPS] = (),
     blending: Literal[BLENDING_OPTIONS] = 'max',
+    saturation_limits: Sequence[tuple[float, float]] = (),
 ) -> np.ndarray: ...

{mergechannels-0.1.0 → mergechannels-0.1.1}/python/mergechannels/_internal.py

@@ -11,24 +11,16 @@ from ._blending import BLENDING_OPTIONS
 
 def merge(
 	arrs: Sequence[np.ndarray],
-	colors: Sequence[COLORMAPS] = (),
+	colors: Sequence[COLORMAPS],
 	blending: BLENDING_OPTIONS = 'max',
 ) -> np.ndarray:
 	'''
 	apply cmaps to arrays and blend the colors
 	'''
+	# region validation
 	n_arrs = len(arrs)
 	n_colors = len(colors)
-	if n_arrs > 0 and n_colors == 0:
-		arr_shapes = [arr.shape for arr in arrs]
-		if not all([len(arr_shape) == 3 for arr_shape in arr_shapes]):
-			raise ValueError(
-				'Expected a sequence of pre-colorized arrays, '
-				f'got {n_arrs} arrays of shapes {arr_shapes}'
-			)
-		# call merge rgb arrs here
-		return np.zeros((3,3))
-	if not n_arrs == n_colors:
+	if not n_arrs == n_colors and n_arrs > 0:
 		raise ValueError(
 			'Expected an equal number of arrays to colorize and colormap names to apply. '
 			f'Got {n_arrs} arrays and {n_colors} colors'
@@ -38,7 +30,17 @@ def merge(
 		raise ValueError(
 			f'Expected every array to have the same shape, got {arr_shapes}'
 		)
-	# call apply and merge rgb arrs here
+	if not len(arr_shapes[0]) == 2:
+		raise ValueError(
+			f'Expected every array to be 2D, got {arr_shapes[0]}'
+		)
+	arr_dtypes = [arr.dtype for arr in arrs]
+	if not len(set(arr_dtypes)) == 1:
+		raise ValueError(
+			f'Expected every array to have the same dtype, got {arr_dtypes}'
+		)
+	# endregion
+	
 	match n_arrs:
 		case 1:
 			return apply_color_map(arr=arrs[0], cmap_name=colors[0])

{mergechannels-0.1.0 → mergechannels-0.1.1}/src/interface.rs

@@ -12,12 +12,6 @@ pub fn apply_color_map_py<'py>(
     arr: PyReadonlyArray2<'py, u8>,
     cmap_name: &str,
 ) -> Bound<'py, PyArray3<u8>> {
-    // Get the ndarray::ArrayView
-    // let array_view: ArrayView = arr.as_array();
-
-    // Get the dtype
-    // let dtype = array_view.dtype();
-    // println!("{dtype}");
     let arr = arr.as_array();
     let cmap = cmaps::load_cmap(cmap_name);
     let rgb = colorize::apply_color_map(arr, cmap);

mergechannels-0.1.1/test.ipynb

@@ -0,0 +1,101 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from skimage import data\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "def to_uint8(arr):\n",
+    "    return (arr * 255).astype('uint8')\n",
+    "\n",
+    "cells, nuclei = data.cells3d().max(axis=0)\n",
+    "cells = to_uint8(cells / cells.max())\n",
+    "nuclei = to_uint8(nuclei / nuclei.max())\n",
+    "fig, (a, b, c) = plt.subplots(1, 3)\n",
+    "a.imshow(cells, cmap='gray')\n",
+    "b.imshow(nuclei, cmap='gray')\n",
+    "\n",
+    "import mergechannels as mc\n",
+    "c.imshow(mc.merge([cells, nuclei], ['Orange Hot', 'Cyan Hot']))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cells.dtype"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.stdout.flush()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

mergechannels-0.1.0/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.4
-Name: mergechannels
-Version: 0.1.0
-Classifier: Programming Language :: Rust
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: numpy>=1.24.4
-License-File: LICENSE
-Requires-Python: >=3.8, <3.13
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# mergechannels
-
-This project was originally conceived because I often find myself wanting to apply and blend colormaps to images while working from Python, and for historical reasons many of my favorite colormaps are distributed as [FIJI](https://imagej.net/software/fiji/) lookup tables. I also care about things likes speed and memory usage (e.g., not casting large arrays to floating point dtypes), so I was interested in seeing if I could at least match matplotlib's colormapping performance with my own hand-rolled colorizer in Rust.
-
-There are other great colormapping libraries available (e.g., [microfilm](https://github.com/guiwitz/microfilm), [cmap](https://github.com/pyapp-kit/cmap)) that are more feature-rich than this projecting on your needs, but which don't address the my goals. My hope is that this project can fill and un-met niche and otherwise maintain full compatibility with these and similar libraries.
-
-## Installation
-
-Install pre-compiled binaries from [PyPI](https://pypi.org/project/mergechannels/):
-```bash
-pip install mergechannels
-```
-
-Build from source on your own machine:
-```bash
-pip install git+https://github.com/zacswider/mergechannels.git
-```
-
-## Usage
-*NOTE*: scikit-image is not a dependency of this project, but is used in the examples below to fetch images.
-
-### colorize a single image
-
-```python
-from skimage import data
-import matplotlib.pyplot as plt
-import mergechannels as mc
-
-img = data.camera()
-fig, ax = plt.subplots()
-ax.imshow(mc.apply_colormap(img, 'Orange Hot'))
-```
-
-### apply a different colormap to each channel
-```python
-from skimage import data
-import matplotlib.pyplot as plt
-import mergechannels as mc
-
-cells, nuclei = data.cells3d().max(axis=0)
-cells = to_uint8(cells / cells.max())       <- broken until normalization is handled
-nuclei = to_uint8(nuclei / nuclei.max())    <- broken until normalization is handled
-fig, (a, b, c) = plt.subplots(1, 3)
-a.imshow(cells, cmap='gray')
-b.imshow(nuclei, cmap='gray')
-
-import mergechannels as mc
-c.imshow(mc.merge([cells, nuclei], ['Orange Hot', 'Cyan Hot']))
-```
-
-## Acknowledgements
-This project incorporates a number of colormaps that were hand-crafted by Christophe Leterrier and were originally distributed here under the MIT license: https://github.com/cleterrier/ChrisLUTs

mergechannels-0.1.0/README.md

@@ -1,52 +0,0 @@
-# mergechannels
-
-This project was originally conceived because I often find myself wanting to apply and blend colormaps to images while working from Python, and for historical reasons many of my favorite colormaps are distributed as [FIJI](https://imagej.net/software/fiji/) lookup tables. I also care about things likes speed and memory usage (e.g., not casting large arrays to floating point dtypes), so I was interested in seeing if I could at least match matplotlib's colormapping performance with my own hand-rolled colorizer in Rust.
-
-There are other great colormapping libraries available (e.g., [microfilm](https://github.com/guiwitz/microfilm), [cmap](https://github.com/pyapp-kit/cmap)) that are more feature-rich than this projecting on your needs, but which don't address the my goals. My hope is that this project can fill and un-met niche and otherwise maintain full compatibility with these and similar libraries.
-
-## Installation
-
-Install pre-compiled binaries from [PyPI](https://pypi.org/project/mergechannels/):
-```bash
-pip install mergechannels
-```
-
-Build from source on your own machine:
-```bash
-pip install git+https://github.com/zacswider/mergechannels.git
-```
-
-## Usage
-*NOTE*: scikit-image is not a dependency of this project, but is used in the examples below to fetch images.
-
-### colorize a single image
-
-```python
-from skimage import data
-import matplotlib.pyplot as plt
-import mergechannels as mc
-
-img = data.camera()
-fig, ax = plt.subplots()
-ax.imshow(mc.apply_colormap(img, 'Orange Hot'))
-```
-
-### apply a different colormap to each channel
-```python
-from skimage import data
-import matplotlib.pyplot as plt
-import mergechannels as mc
-
-cells, nuclei = data.cells3d().max(axis=0)
-cells = to_uint8(cells / cells.max())       <- broken until normalization is handled
-nuclei = to_uint8(nuclei / nuclei.max())    <- broken until normalization is handled
-fig, (a, b, c) = plt.subplots(1, 3)
-a.imshow(cells, cmap='gray')
-b.imshow(nuclei, cmap='gray')
-
-import mergechannels as mc
-c.imshow(mc.merge([cells, nuclei], ['Orange Hot', 'Cyan Hot']))
-```
-
-## Acknowledgements
-This project incorporates a number of colormaps that were hand-crafted by Christophe Leterrier and were originally distributed here under the MIT license: https://github.com/cleterrier/ChrisLUTs