ocdkit 0.0.1__tar.gz

ocdkit-0.0.1/.github/workflows/test_and_deploy.yml

@@ -0,0 +1,111 @@
+name: CI/CD
+
+on:
+  push:
+    tags:
+      - "v*"  # e.g. v1.0, v2.0
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }} (Python ${{ matrix.python_version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]  # macos-latest = Apple Silicon (MPS)
+        python_version: ['3.11', '3.12']
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # needed for setuptools_scm
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python_version }}
+          cache: pip
+
+      - name: Install package with dev deps
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          pip install --extra-index-url https://download.pytorch.org/whl/cpu \
+            -e . pytest pytest-cov
+
+      - name: Run tests
+        shell: bash
+        env:
+          PYTORCH_ENABLE_MPS_FALLBACK: "1"
+        run: |
+          python -m pytest tests/ \
+            --cov=ocdkit --cov-report=xml --cov-report=term \
+            --junitxml=junit.xml \
+            -v
+
+      - name: Upload coverage & junit artifacts
+        if: matrix.os == 'macos-latest' && matrix.python_version == '3.11'
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: |
+            coverage.xml
+            junit.xml
+
+  deploy:
+    name: Deploy to PyPI
+    runs-on: ubuntu-latest
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine setuptools setuptools_scm wheel
+
+      - name: Build distribution
+        run: python -m build --sdist --wheel
+
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.TWINE_API_KEY }}
+        run: python -m twine upload dist/*
+
+  badges:
+    name: Build and commit badges
+    runs-on: ubuntu-latest
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download test artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: test-results
+
+      - name: Install badge dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install 'genbadge[coverage,tests]'
+
+      - name: Generate badges
+        run: |
+          mkdir -p badges
+          genbadge coverage -i coverage.xml -o badges/coverage.svg
+          genbadge tests -i junit.xml -o badges/tests.svg
+
+      - name: Commit badges
+        uses: EndBug/add-and-commit@v9
+        with:
+          add: 'badges/*.svg'
+          message: 'CI: update coverage and test badges'

ocdkit-0.0.1/.gitignore

@@ -0,0 +1,89 @@
+# Byte-compiled / optimized / DLL files
+**/__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# macOS resource fork / metadata junk
+._*
+.DS_Store
+.AppleDouble
+.AppleDB
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+*_version.py
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Sphinx documentation
+docs/_build/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json

ocdkit-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Kevin Cutler
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

ocdkit-0.0.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: ocdkit
+Version: 0.0.1
+Summary: Obsessively precise utilities for array manipulation, GPU dispatch, image I/O, morphology, and plotting.
+License: BSD-3-Clause
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: tifffile
+Requires-Dist: imagecodecs
+Requires-Dist: matplotlib
+Requires-Dist: fastremap
+Requires-Dist: edt
+Requires-Dist: torch>=1.12
+Requires-Dist: dask[array]
+Requires-Dist: natsort
+Requires-Dist: numba
+Requires-Dist: bioio
+Requires-Dist: bioio-czi
+Requires-Dist: ncolor>=1.5.1
+Requires-Dist: cmap
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# ocdkit
+
+Obsessively precise utilities for scientific Python — array manipulation, GPU dispatch, image I/O, spatial operations, morphology, and plotting.
+
+## Install
+
+```bash
+pip install ocdkit             # core (numpy, scipy, scikit-image, tifffile, matplotlib)
+pip install ocdkit[torch]      # + PyTorch GPU support
+pip install ocdkit[plot]       # + ncolor, cmap, opt_einsum
+pip install ocdkit[spatial]    # + numba, fastremap (contour extraction, skeletonization)
+pip install ocdkit[all]        # everything
+```
+
+## Modules
+
+| Module | What's in it |
+|---|---|
+| `ocdkit.array` | `rescale`, `safe_divide`, `is_integer`, `get_module`, `unique_nonzero` |
+| `ocdkit.gpu` | `resolve_device`, `empty_cache`, `torch_GPU`, `torch_CPU` |
+| `ocdkit.io` | `imread`, `imwrite`, `getname`, `check_dir` |
+| `ocdkit.spatial` | `kernel_setup`, `get_neighbors`, `get_neigh_inds`, `masks_to_affinity`, `get_contour`, `boundary_to_masks` |
+| `ocdkit.morphology` | `find_boundaries`, `skeletonize` |
+| `ocdkit.measure` | `crop_bbox`, `bbox_to_slice`, `make_square`, `diameters` |
+| `ocdkit.plot` | `figure`, `image_grid`, `split_list`, `colorize`, `rgb_flow`, `vector_contours`, `apply_ncolor`, `color_swatches`, `recolor_label`, `add_label_background` |
+
+## Quick start
+
+```python
+from ocdkit.array import rescale
+from ocdkit.gpu import resolve_device
+from ocdkit.plot import figure, image_grid
+
+device = resolve_device()  # auto-detect CUDA / MPS / CPU
+```
+
+## License
+
+BSD-3-Clause

ocdkit-0.0.1/README.md

@@ -0,0 +1,39 @@
+# ocdkit
+
+Obsessively precise utilities for scientific Python — array manipulation, GPU dispatch, image I/O, spatial operations, morphology, and plotting.
+
+## Install
+
+```bash
+pip install ocdkit             # core (numpy, scipy, scikit-image, tifffile, matplotlib)
+pip install ocdkit[torch]      # + PyTorch GPU support
+pip install ocdkit[plot]       # + ncolor, cmap, opt_einsum
+pip install ocdkit[spatial]    # + numba, fastremap (contour extraction, skeletonization)
+pip install ocdkit[all]        # everything
+```
+
+## Modules
+
+| Module | What's in it |
+|---|---|
+| `ocdkit.array` | `rescale`, `safe_divide`, `is_integer`, `get_module`, `unique_nonzero` |
+| `ocdkit.gpu` | `resolve_device`, `empty_cache`, `torch_GPU`, `torch_CPU` |
+| `ocdkit.io` | `imread`, `imwrite`, `getname`, `check_dir` |
+| `ocdkit.spatial` | `kernel_setup`, `get_neighbors`, `get_neigh_inds`, `masks_to_affinity`, `get_contour`, `boundary_to_masks` |
+| `ocdkit.morphology` | `find_boundaries`, `skeletonize` |
+| `ocdkit.measure` | `crop_bbox`, `bbox_to_slice`, `make_square`, `diameters` |
+| `ocdkit.plot` | `figure`, `image_grid`, `split_list`, `colorize`, `rgb_flow`, `vector_contours`, `apply_ncolor`, `color_swatches`, `recolor_label`, `add_label_background` |
+
+## Quick start
+
+```python
+from ocdkit.array import rescale
+from ocdkit.gpu import resolve_device
+from ocdkit.plot import figure, image_grid
+
+device = resolve_device()  # auto-detect CUDA / MPS / CPU
+```
+
+## License
+
+BSD-3-Clause

ocdkit-0.0.1/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=61.0", "setuptools_scm>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ocdkit"
+dynamic = ["version"]
+description = "Obsessively precise utilities for array manipulation, GPU dispatch, image I/O, morphology, and plotting."
+readme = "README.md"
+license = {text = "BSD-3-Clause"}
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "scipy",
+    "scikit-image",
+    "tifffile",
+    "imagecodecs",
+    "matplotlib",
+    "fastremap",
+    "edt",
+    "torch>=1.12",
+    "dask[array]",
+    "natsort",
+    "numba",
+    "bioio",
+    "bioio-czi",
+    "ncolor>=1.5.1",
+    "cmap",
+    "tqdm",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+source = ["ocdkit"]
+
+[tool.coverage.paths]
+source = [
+    "src/ocdkit",
+    "/Volumes/DataDrive/ocdkit/src/ocdkit",
+    "/home/kcutler/DataDrive/ocdkit/src/ocdkit",
+]
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.setuptools_scm]

ocdkit-0.0.1/scripts/bench_colorize.py

@@ -0,0 +1,104 @@
+"""Benchmark colorize: matmul vs opt_einsum across backends and shapes."""
+
+import time, string
+import numpy as np
+import torch
+from opt_einsum import contract
+
+
+def make_colors(C):
+    angle = np.linspace(0, 1, C, endpoint=False) * 2 * np.pi
+    angles = np.stack((angle, angle + 2*np.pi/3, angle + 4*np.pi/3), axis=-1)
+    return ((np.cos(angles) + 1) / 2).astype(np.float32)
+
+
+def bench(fn, n_warmup=3, n_iter=10):
+    for _ in range(n_warmup):
+        fn()
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    t0 = time.perf_counter()
+    for _ in range(n_iter):
+        fn()
+    if torch.cuda.is_available():
+        torch.cuda.synchronize()
+    return (time.perf_counter() - t0) / n_iter * 1000
+
+
+configs = [
+    (126, (2000, 2000), [126],        '126ch 2kx2k single'),
+    (126, (2000, 2000), [42,42,42],   '126ch 2kx2k 3-int'),
+    (126, (10000, 100), [126],        '126ch 10kx100 single'),
+    (256, (5000, 50),   [64]*4,       '256ch 5kx50 4-int'),
+    (512, (1000, 1000), [512],        '512ch 1kx1k single'),
+    (512, (1000, 1000), [128]*4,      '512ch 1kx1k 4-int'),
+    (1024,(500, 500),   [1024],       '1024ch 500x500 single'),
+    (126, (100, 100, 100),[126],      '126ch 100^3 single'),
+    (256, (32, 32),     [256],        '256ch 32x32 single'),
+    (3,   (4000, 4000), [3],          '3ch 4kx4k single'),
+    (8,   (4000, 4000), [4,4],        '8ch 4kx4k 2-int'),
+]
+
+devices = ['cpu']
+if torch.cuda.is_available():
+    devices.append('cuda')
+if torch.backends.mps.is_available():
+    devices.append('mps')
+
+for device_name in devices:
+    device = torch.device(device_name)
+    print(f"\n{'='*95}")
+    print(f"  Device: {device_name.upper()}")
+    print(f"{'='*95}")
+    print(f"{'Config':<35} {'np mm':>8} {'np ein':>8} {'t mm':>8} {'t ein':>8}  np    torch")
+    print('-' * 95)
+
+    for C, spatial, intervals, label in configs:
+        N = len(intervals)
+        im_np = np.random.rand(C, *spatial).astype(np.float32)
+        colors = make_colors(C)
+        agg = np.zeros((C, N), dtype=np.float32)
+        s = 0
+        for i, sz in enumerate(intervals):
+            agg[s:s+sz, i] = 1.0/sz
+            s += sz
+
+        idx = ''.join(c for c in string.ascii_lowercase if c not in 'cl')
+        sp = idx[:len(spatial)]
+        eq = f'c{sp},cN,cl->N{sp}l'
+
+        # Numpy (always CPU)
+        def np_mm():
+            w = (agg[...,None]*colors[:,None,:]).reshape(C,N*3)
+            return w.T @ im_np.reshape(C,-1)
+        def np_ein():
+            return contract(eq, im_np, agg, colors)
+
+        t1 = bench(np_mm)
+        t2 = bench(np_ein)
+
+        # Torch on target device
+        im_t = torch.from_numpy(im_np).to(device)
+        agg_t = torch.from_numpy(agg).to(device)
+        col_t = torch.from_numpy(colors).to(device)
+
+        def t_mm():
+            w = (agg_t[...,None]*col_t[:,None,:]).reshape(C,N*3).float()
+            return w.T @ im_t.reshape(C,-1).float()
+        def t_ein():
+            return contract(eq, im_t.float(), agg_t, col_t)
+
+        t3 = bench(t_mm)
+        t4 = bench(t_ein)
+
+        np_w = 'ein' if t2 < t1 else 'mm'
+        t_w = 'ein' if t4 < t3 else 'mm'
+        np_r = max(t1,t2)/min(t1,t2)
+        t_r = max(t3,t4)/min(t3,t4)
+
+        print(f'{label:<35} {t1:>6.1f}ms {t2:>6.1f}ms {t3:>6.1f}ms {t4:>6.1f}ms  {np_w}({np_r:.1f}x) {t_w}({t_r:.1f}x)')
+
+        # Free GPU memory
+        del im_t, agg_t, col_t
+        if device_name != 'cpu':
+            torch.cuda.empty_cache() if device_name == 'cuda' else torch.mps.empty_cache()

ocdkit-0.0.1/scripts/coverage_cross_device.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+#
+# Run ocdkit tests on Mac (MPS), Threadripper (CUDA), and
+# Threadripper with CUDA disabled (CPU-only), then combine coverage.
+# Notebook-based tests (IPython/Jupyter-dependent code) run on Mac only.
+#
+# Usage:  bash scripts/coverage_cross_device.sh
+#
+set -euo pipefail
+
+MAC_ROOT="/Volumes/DataDrive/ocdkit"
+REMOTE_ROOT="/home/kcutler/DataDrive/ocdkit"
+REMOTE="kcutler@threadripper.local"
+PYENV='export PATH="$HOME/.pyenv/shims:$HOME/.pyenv/bin:$PATH"'
+COV_DIR="$MAC_ROOT/.coverage_combined"
+
+rm -rf "$COV_DIR"
+mkdir -p "$COV_DIR"
+
+echo "=== Mac (MPS) ==="
+cd "$MAC_ROOT"
+python -m coverage run --data-file="$COV_DIR/.coverage.mac" -m pytest tests/ -q
+
+echo ""
+echo "=== Threadripper (CUDA) ==="
+ssh "$REMOTE" "$PYENV && cd $REMOTE_ROOT && python -m coverage run --data-file=/tmp/.coverage.cuda -m pytest tests/ -q --ignore=tests/test_plot_notebook.py"
+scp "$REMOTE":/tmp/.coverage.cuda "$COV_DIR/.coverage.cuda"
+
+echo ""
+echo "=== Threadripper (CPU-only) ==="
+ssh "$REMOTE" "$PYENV && cd $REMOTE_ROOT && CUDA_VISIBLE_DEVICES='' python -m coverage run --data-file=/tmp/.coverage.cpu -m pytest tests/ -q --ignore=tests/test_plot_notebook.py"
+scp "$REMOTE":/tmp/.coverage.cpu "$COV_DIR/.coverage.cpu"
+
+echo ""
+echo "=== Combining coverage ==="
+cd "$MAC_ROOT"
+python -m coverage combine --data-file="$COV_DIR/.coverage" "$COV_DIR"/.coverage.*
+python -m coverage report --data-file="$COV_DIR/.coverage" --show-missing
+echo ""
+python -m coverage html --data-file="$COV_DIR/.coverage" -d "$COV_DIR/htmlcov"
+echo "HTML report: file://$COV_DIR/htmlcov/index.html"

ocdkit-0.0.1/setup.cfg

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

ocdkit-0.0.1/src/ocdkit/__init__.py

@@ -0,0 +1,10 @@
+"""
+ocdkit — Obsessively precise utilities for scientific Python.
+
+Array manipulation, GPU dispatch, image I/O, morphology, and plotting
+tools shared across projects.
+"""
+
+from .load import enable_submodules
+
+enable_submodules(__name__)

ocdkit-0.0.1/src/ocdkit/array/__init__.py

@@ -0,0 +1,3 @@
+from ..load import enable_submodules
+
+enable_submodules(__name__)

ocdkit-0.0.1/src/ocdkit/array/convert.py

@@ -0,0 +1,121 @@
+"""Type detection, conversion, and rescaling utilities."""
+
+from .imports import *
+
+
+def get_module(x):
+    """Return ``np`` or ``torch`` depending on the type of *x*."""
+    if isinstance(x, da.Array):
+        return np
+    if isinstance(x, (np.ndarray, tuple, int, float)) or np.isscalar(x):
+        return np
+    if torch.is_tensor(x):
+        return torch
+    raise ValueError(
+        "Input must be a numpy array, a tuple, a torch tensor, "
+        "an integer, or a float"
+    )
+
+
+def safe_divide(num, den, cutoff=0):
+    """Division ignoring zeros and NaNs in the denominator."""
+    module = get_module(num)
+    valid_den = (den > cutoff) & module.isfinite(den)
+
+    if isinstance(num, da.Array) or isinstance(den, da.Array):
+        return da.where(valid_den, num / den, 0)
+    elif module == np:
+        r = num.astype(np.float32, copy=False)
+        r = np.divide(r, den, out=np.zeros_like(r), where=valid_den)
+    elif module == torch:
+        r = num.float()
+        den = den.float()
+        safe_den = torch.where(valid_den, den, torch.ones_like(den))
+        r = torch.where(valid_den, torch.div(r, safe_den), torch.zeros_like(r))
+    else:
+        raise TypeError("num must be a numpy array or a PyTorch tensor")
+
+    return r
+
+
+def rescale(T, floor=None, ceiling=None, exclude_dims=None):
+    """Min-max rescale to [0, 1].
+
+    Works on numpy arrays and torch tensors.  When *exclude_dims* is
+    given, normalization is applied independently along those axes.
+    """
+    module = get_module(T)
+    if exclude_dims is not None:
+        if isinstance(exclude_dims, int):
+            exclude_dims = (exclude_dims,)
+        axes = tuple(i for i in range(T.ndim) if i not in exclude_dims)
+        newshape = [T.shape[i] if i in exclude_dims else 1 for i in range(T.ndim)]
+    else:
+        axes = None
+        newshape = T.shape
+
+    if ceiling is None:
+        ceiling = module.amax(T, axis=axes)
+        if exclude_dims is not None:
+            ceiling = ceiling.reshape(*newshape)
+    if floor is None:
+        floor = module.amin(T, axis=axes)
+        if exclude_dims is not None:
+            floor = floor.reshape(*newshape)
+
+    T = safe_divide(T - floor, ceiling - floor)
+
+    return T
+
+
+def to_16_bit(im):
+    """Rescale image to [0, 2**16 - 1] and cast to uint16."""
+    return np.uint16(rescale(im) * (2 ** 16 - 1))
+
+
+def to_8_bit(im):
+    """Rescale image to [0, 2**8 - 1] and cast to uint8."""
+    return np.uint8(rescale(im) * (2 ** 8 - 1))
+
+
+def is_integer(var):
+    """Check whether *var* is an integer or integer-typed array/tensor."""
+    if isinstance(var, int):
+        return True
+    if isinstance(var, np.integer):
+        return True
+    if isinstance(var, (np.ndarray, np.memmap)) and np.issubdtype(var.dtype, np.integer):
+        return True
+    if isinstance(var, da.Array) and np.issubdtype(var.dtype, np.integer):
+        return True
+    if isinstance(var, torch.Tensor) and not var.is_floating_point():
+        return True
+    return False
+
+
+def move_axis(img, axis=-1, pos="last"):
+    """Move ndarray axis to a new location, preserving order of other axes."""
+    if axis == -1:
+        axis = img.ndim - 1
+    axis = min(img.ndim - 1, axis)
+    if pos in ("first", 0):
+        pos = 0
+    elif pos in ("last", -1):
+        pos = img.ndim - 1
+    perm = list(range(img.ndim))
+    perm.pop(axis)
+    perm.insert(pos, axis)
+    return np.transpose(img, perm)
+
+
+def move_min_dim(img, force=False):
+    """Move the minimum-sized dimension last (as channels) if < 10."""
+    if len(img.shape) > 2:
+        min_dim = min(img.shape)
+        if min_dim < 10 or force:
+            if img.shape[-1] == min_dim:
+                channel_axis = -1
+            else:
+                channel_axis = (img.shape).index(min_dim)
+            img = move_axis(img, axis=channel_axis, pos="last")
+    return img