tinybrain 1.6.0__tar.gz → 1.8.0__tar.gz

tinybrain-1.8.0/.github/workflows/build_wheel.yml

@@ -0,0 +1,39 @@
+name: Build Wheels
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*'
+env:
+  CIBW_SKIP: pp* cp315t*
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{matrix.arch}} for ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        arch: [auto]
+        include:
+          - os: ubuntu-24.04-arm
+            arch: aarch64
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheels
+        uses: joerick/cibuildwheel@v4.2.0
+        # to supply options, put them in 'env', like:
+        env:
+          CIBW_BEFORE_BUILD: pip install numpy pybind11 setuptools wheel pkginfo twine
+          CIBW_ARCHS_MACOS: "x86_64 arm64"
+          CIBW_ARCHS: auto64
+
+      - name: Upload built wheels
+        uses: actions/upload-artifact@v4
+        with:
+          name: built-wheels-${{ matrix.os }}-${{ matrix.arch }}
+          path: ./wheelhouse/*.whl
+          if-no-files-found: warn

{tinybrain-1.6.0 → tinybrain-1.8.0}/.github/workflows/run_tests.yml

@@ -14,8 +14,8 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-2019]
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
 
     steps:
       - name: Set up Python ${{ matrix.python-version }}
@@ -23,7 +23,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v7
 
       - name: Install dependencies
         run: |

{tinybrain-1.6.0 → tinybrain-1.8.0}/ChangeLog

@@ -1,6 +1,28 @@
 CHANGES
 =======
 
+1.8.0
+-----
+
+* ci: skip building cp315t
+* release(1.8.0): support boolean images, faster 2x2x2 mode downsampling
+* ci: update build
+* fix: error and missing optimization
+* test: add compliance test for end of 2x2x2
+* docs: update performance numbers for 2x2x2 mode
+* perf: faster 2x2x2 mode downsampling
+* feat: support mode pooling for boolean images
+* test: update benchmark with Macbook Pro M3 + add pillow, opencv
+
+1.7.0
+-----
+
+* fix: warnings about type comparison
+* install: bump to c++17
+* feat: add int8, int16 to downsample\_with\_averaging (#23)
+* chore: update python compatible versions to drop 3.8 (EOL)
+* docs: remove travis badge
+
 1.6.0
 -----
 

{tinybrain-1.6.0 → tinybrain-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: tinybrain
-Version: 1.6.0
+Version: 1.8.0
 Summary: Image pyramid generation specialized for connectomics data types and procedures.
 Home-page: https://github.com/seung-lab/tinybrain/
 Author: William Silversmith
@@ -9,19 +9,28 @@ Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 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: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: numpy
-
-[![Build Status](https://travis-ci.org/seung-lab/tinybrain.svg?branch=master)](https://travis-ci.org/seung-lab/tinybrain) [![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
 
 # tinybrain
 
@@ -37,7 +46,12 @@ img = load_3d_em_stack()
 img_pyramid = tinybrain.downsample_with_averaging(img, factor=(2,2,1), num_mips=5, sparse=False)
 
 labels = load_3d_labels()
-label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False))
+label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False)
+
+# We also have a few other types
+img_pyramid = tinybrain.downsample_with_min_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_max_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_striding(image, factor=(2,2,1), num_mips=5)
 ```
 
 ## Installation 
@@ -50,7 +64,7 @@ pip install tinybrain
 ## Motivation
 
 Image hierarchy generation in connectomics uses a few different techniques for
-visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualze upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
+visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualize upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
 
 It's possible to compute both of these using numpy, however as multiple packages found it useful to copy the downsample functions, it makes sense to formalize these functions into a seperate library located on PyPI.
 

{tinybrain-1.6.0 → tinybrain-1.8.0}/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/seung-lab/tinybrain.svg?branch=master)](https://travis-ci.org/seung-lab/tinybrain) [![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
+[![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
 
 # tinybrain
 
@@ -14,7 +14,12 @@ img = load_3d_em_stack()
 img_pyramid = tinybrain.downsample_with_averaging(img, factor=(2,2,1), num_mips=5, sparse=False)
 
 labels = load_3d_labels()
-label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False))
+label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False)
+
+# We also have a few other types
+img_pyramid = tinybrain.downsample_with_min_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_max_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_striding(image, factor=(2,2,1), num_mips=5)
 ```
 
 ## Installation 
@@ -27,7 +32,7 @@ pip install tinybrain
 ## Motivation
 
 Image hierarchy generation in connectomics uses a few different techniques for
-visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualze upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
+visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualize upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
 
 It's possible to compute both of these using numpy, however as multiple packages found it useful to copy the downsample functions, it makes sense to formalize these functions into a seperate library located on PyPI.
 

{tinybrain-1.6.0 → tinybrain-1.8.0}/automated_test.py

@@ -125,7 +125,7 @@ def test_even_odd2d():
   assert np.array_equal(oddimg, ans3x3x3)
   assert np.array_equal(oddimgf, ans3x3x3)
 
-@pytest.mark.parametrize("dtype", (np.uint8, np.uint16, np.float32, np.float64))
+@pytest.mark.parametrize("dtype", (np.int8, np.int16, np.uint8, np.uint16, np.float32, np.float64))
 @pytest.mark.parametrize("sparse", [False, True])
 def test_accelerated_vs_numpy_avg_pooling_2x2x1(dtype, sparse):
   image = np.random.randint(0,255, size=(512, 512, 6), dtype=np.uint8).astype(dtype, copy=False)
@@ -147,7 +147,7 @@ def test_accelerated_vs_numpy_avg_pooling_2x2x1(dtype, sparse):
 
   assert np.all(mips[-1] == npimg)
 
-@pytest.mark.parametrize("dtype", (np.uint8, np.uint16, np.float32, np.float64))
+@pytest.mark.parametrize("dtype", (np.int8, np.int16, np.uint8, np.uint16, np.float32, np.float64))
 def test_accelerated_vs_numpy_avg_pooling_2x2x1_simple_sparse(dtype):
   for x in [0,1]:
     for y in [0,1]:
@@ -189,7 +189,7 @@ def test_accelerated_vs_numpy_avg_pooling_2x2x1_simple_sparse(dtype):
   assert np.all(res[1] == ans)
 
 
-@pytest.mark.parametrize("dtype", (np.uint8, np.uint16, np.float32, np.float64))
+@pytest.mark.parametrize("dtype", (np.int8, np.int16, np.uint8, np.uint16, np.float32, np.float64))
 @pytest.mark.parametrize("sx", (6,7,1024,1025))
 @pytest.mark.parametrize("sy", (6,7,1024,1025))
 @pytest.mark.parametrize("sz", (4,5,32,33))
@@ -700,6 +700,21 @@ def test_sparse_2x2x2_mode_downsampling(dtype):
   assert res[0][0][0] == 0
   assert res.shape == (1,1,1)
 
+  test7 = np.array([
+    [
+      [1,2],
+      [3,4],
+    ],
+    [
+      [5,6],
+      [7,8],
+    ],
+  ], dtype=dtype, order='F')
+
+  res = tinybrain.accelerated.mode_pooling_2x2x2(test7, sparse=True)[0]
+  assert res[0][0][0] == 1
+  assert res.shape == (1,1,1)
+
   # test7 = np.array([
   #   [
   #     [1,0,1],

{tinybrain-1.6.0 → tinybrain-1.8.0}/perf.py

@@ -27,6 +27,26 @@
 # 2x2x2 1 mip sparse: 0.656s, 2041.96 MVx/sec, N=10
 # 2x2x2 2 mip sparse: 0.762s, 1758.42 MVx/sec, N=10
 
+# Results on a 2023 Macbook Pro M3
+# AVG POOLING ((2048, 2048, 64), uint8)
+# 2x2 1 mip: 0.084s, 31954.51 MVx/sec, N=10
+# 2x2 2 mip: 0.223s, 11995.13 MVx/sec, N=10
+# 2x2x2 1 mip: 0.042s, 63958.66 MVx/sec, N=10
+# 2x2x2 2 mip: 0.218s, 12303.19 MVx/sec, N=10
+# 2x2x2 1 mip sparse: 0.581s, 4612.79 MVx/sec, N=10
+# 2x2x2 2 mip sparse: 0.686s, 3908.00 MVx/sec, N=10
+# 2x2 1 mip pillow: 10.526s, 254.61 MVx/sec, N=10
+# 2x2 1 mip opencv: 5.352s, 500.79 MVx/sec, N=10
+# MODE POOLING ((2048, 2048, 64), uint64)
+# 2x2 1 mip: 1.030s, 2602.65 MVx/sec, N=10
+# 2x2 2 mip: 1.181s, 2269.54 MVx/sec, N=10
+# 2x2 1 mip sparse: 14.294s, 187.49 MVx/sec, N=10
+# 2x2 2 mip sparse: 25.615s, 104.63 MVx/sec, N=10
+# 2x2x2 1 mip: 3.171s, 845.10 MVx/sec, N=10
+# 2x2x2 2 mip: 3.479s, 770.30 MVx/sec, N=10
+# 2x2x2 1 mip sparse: 3.461s, 774.31 MVx/sec, N=10
+# 2x2x2 2 mip sparse: 3.916s, 684.42 MVx/sec, N=10
+
 import numpy as np
 import tinybrain
 import time
@@ -80,6 +100,33 @@ def benchmark_avg_pooling():
 	end = time.time()
 	result("2x2x2 2 mip sparse", end - start, data, N)
 
+	try:
+		from PIL import Image
+		s = time.time()
+		out = np.zeros([1024,1024,64], dtype=np.uint8, order="F")
+		for _ in range(N):
+			for z in range(data.shape[2]):
+			  pilimg = Image.fromarray(data[:,:,z])
+			  out[:,:,z] = pilimg.resize( (1024, 1024) )
+		end = time.time()
+		result("2x2 1 mip pillow", end - start, data, N)
+		del out
+	except ImportError:
+		print("Pillow not installed.")
+
+	try:
+		import cv2
+		start = time.time()
+		out = np.zeros(shape=(1024,1024,64))
+		for _ in range(N):
+			for z in range(data.shape[2]):
+			  out[:,:,z] = cv2.resize(data[:,:,z], dsize=(1024, 1024) )
+		end = time.time()
+		result("2x2 1 mip opencv", end - start, data, N)
+		del out
+	except ImportError:
+		print("opencv not installed.")
+
 def benchmark_mode_pooling():
 	data = np.random.randint(1000,1255, size=(2048,2048,64), dtype=np.uint64)
 	data = np.asfortranarray(data)

{tinybrain-1.6.0 → tinybrain-1.8.0}/setup.cfg

@@ -13,11 +13,11 @@ classifier =
 	Development Status :: 5 - Production/Stable
 	License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 	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
+	Programming Language :: Python :: 3.13
 	Topic :: Scientific/Engineering
 
 [global]

{tinybrain-1.6.0 → tinybrain-1.8.0}/setup.py

@@ -17,13 +17,13 @@ class NumpyImport:
 extra_compile_args = []
 if sys.platform == 'win32':
   extra_compile_args += [
-    '/std:c++11', '/O2'
+    '/std:c++17', '/O2'
   ]
   if platform.machine() == "x86_64":
     extra_compile_args += [ "/arch:SSE3" ]
 else:
   extra_compile_args += [
-    '-std=c++11', '-O3' # '-DCYTHON_TRACE=1'
+    '-std=c++17', '-O3' # '-DCYTHON_TRACE=1'
   ]
   if platform.machine() == "x86_64":
     extra_compile_args += [ '-msse3' ]
@@ -34,7 +34,7 @@ if sys.platform == 'darwin':
 setuptools.setup(
   setup_requires=['pbr', 'numpy','cython'],
   install_requires=['numpy'],
-  python_requires=">=3.8",
+  python_requires=">=3.9",
   ext_modules=[
     setuptools.Extension(
       'tinybrain.accelerated',

{tinybrain-1.6.0 → tinybrain-1.8.0}/tinybrain/__init__.py

@@ -7,4 +7,4 @@ from .downsample import (
   DimensionError
 )
 
-__version__ = '1.4.1'
+__version__ = '1.8.0'

{tinybrain-1.6.0 → tinybrain-1.8.0}/tinybrain/accelerated.hpp

@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2019, William Silversmith
+Copyright (C) 2019,2025 William Silversmith
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -359,7 +359,7 @@ T* _average_pooling_2x2_single_mip(
                   + static_cast<T2>(d)
                 ) / static_cast<T2>(
                     std::max(
-                      static_cast<T>((a > 0) + (b > 0) + (c > 0) + (d > 0)),
+                      static_cast<T>((a != 0) + (b != 0) + (c != 0) + (d != 0)),
                       static_cast<T>(1)
                     )
                   )
@@ -375,7 +375,7 @@ T* _average_pooling_2x2_single_mip(
                   + static_cast<T2>(b)
                 ) / static_cast<T2>(
                   std::max(
-                    static_cast<T>((a > 0) + (b > 0)),
+                    static_cast<T>((a != 0) + (b != 0)),
                     static_cast<T>(1)
                 )
               ));
@@ -931,8 +931,17 @@ U* denominator_2x2x2(
 
 template <typename T, typename U>
 inline void render_image(T* accum, U* oimg, const uint32_t bitshift, const size_t ovoxels) {
-  for (size_t i = 0; i < ovoxels; i++) {
-    oimg[i] = static_cast<U>(accum[i] >> bitshift);
+  if constexpr (std::is_signed<T>::value) {
+    for (size_t i = 0; i < ovoxels; i++) {
+      oimg[i] = (accum[i] < 0) 
+        ? -static_cast<U>(std::abs(accum[i]) >> bitshift)
+        : static_cast<U>(accum[i] >> bitshift);
+    }
+  } 
+  else {
+    for (size_t i = 0; i < ovoxels; i++) {
+      oimg[i] = static_cast<U>(accum[i] >> bitshift);
+    }
   }
 }
 
@@ -1105,19 +1114,26 @@ inline void _mode_pooling_2x2x2(
               continue;
             }
 
-            max_ct = 0;
-            max_val = 0;
-            for (short int t = 0; t < 8; t++) {
+            if (sparse && vals[0] == 0) {
+              max_ct = 0;
+              max_val = 0;
+            }
+            else {
+              max_ct = 1;
+              max_val = vals[0];
+            }
+
+            // no need to evaluate t=0, as if max_ct
+            // is 1 at the last entry, it can't go higher than
+            // 1, so we'll just take the last entry as good
+            for (short int t = 7; t >= 1; t--) {
               cur_val = vals[t];
               if (sparse && cur_val == 0) {
                 continue;
               }
 
               cur_ct = 1;
-              for (short int p = 0; p < t; p++) {
-                cur_ct += (cur_val == vals[p]);
-              }
-              for (short int p = t + 1; p < 8; p++) {
+              for (short int p = t-1; p >= 0; p--) {
                 cur_ct += (cur_val == vals[p]);
               }
 

{tinybrain-1.6.0 → tinybrain-1.8.0}/tinybrain/accelerated.pyx

@@ -4,7 +4,7 @@ Cython accelerated routines for common downsampling operations.
 
 Author: William Silversmith
 Affiliation: Seung Lab, Princeton Neuroscience Institute
-Date: March 2019
+Date: March 2019, Februrary 2025
 """
 cimport cython
 from cython cimport floating
@@ -94,8 +94,12 @@ def average_pooling_2x2(channel, size_t num_mips=1, sparse=False):
     results = _average_pooling_2x2_single_mip_py(channel, sparse)
   elif channel.dtype == np.uint8:
     results = _average_pooling_2x2_uint8(channel, num_mips, sparse)
+  elif channel.dtype == np.int8:
+    results = _average_pooling_2x2_int8(channel, num_mips, sparse)
   elif channel.dtype == np.uint16:
     results = _average_pooling_2x2_uint16(channel, num_mips, sparse)
+  elif channel.dtype == np.int16:
+    results = _average_pooling_2x2_int16(channel, num_mips, sparse)
   elif channel.dtype == np.float32:
     results = _average_pooling_2x2_float(channel, num_mips, sparse)
   elif channel.dtype == np.float64:
@@ -109,17 +113,29 @@ def average_pooling_2x2(channel, size_t num_mips=1, sparse=False):
   return results
 
 def _average_pooling_2x2_single_mip_py(np.ndarray[NUMBER, ndim=5] channel, sparse):
+  cdef int8_t[:,:,:,:,:] arr_memview8i
+  cdef int16_t[:,:,:,:,:] arr_memview16i
+  cdef int32_t[:,:,:,:,:] arr_memview32i
+  cdef int64_t[:,:,:,:,:] arr_memview64i
+
   cdef uint8_t[:,:,:,:,:] arr_memview8u
   cdef uint16_t[:,:,:,:,:] arr_memview16u
   cdef uint32_t[:,:,:,:,:] arr_memview32u
   cdef uint64_t[:,:,:,:,:] arr_memview64u
+  
   cdef float[:,:,:,:,:] arr_memviewf
   cdef double[:,:,:,:,:] arr_memviewd
 
+  cdef int8_t[:,:,:,:,:] out_memview8i
+  cdef int16_t[:,:,:,:,:] out_memview16i
+  cdef int32_t[:,:,:,:,:] out_memview32i
+  cdef int64_t[:,:,:,:,:] out_memview64i
+
   cdef uint8_t[:,:,:,:,:] out_memview8u
   cdef uint16_t[:,:,:,:,:] out_memview16u
   cdef uint32_t[:,:,:,:,:] out_memview32u
   cdef uint64_t[:,:,:,:,:] out_memview64u
+  
   cdef float[:,:,:,:,:] out_memviewf
   cdef double[:,:,:,:,:] out_memviewd
 
@@ -149,6 +165,22 @@ def _average_pooling_2x2_single_mip_py(np.ndarray[NUMBER, ndim=5] channel, spars
     arr_memview64u = channel
     out_memview64u = out
     _average_pooling_2x2_single_mip[uint64_t](&arr_memview64u[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview64u[0,0,0,0,0], bool(sparse))
+  elif channel.dtype == np.int8:
+    arr_memview8i = channel
+    out_memview8i = out
+    _average_pooling_2x2_single_mip[int8_t](&arr_memview8i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview8i[0,0,0,0,0], bool(sparse))
+  elif channel.dtype == np.int16:
+    arr_memview16i = channel
+    out_memview16i = out
+    _average_pooling_2x2_single_mip[int16_t](&arr_memview16i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview16i[0,0,0,0,0], bool(sparse))
+  elif channel.dtype == np.int32:
+    arr_memview32i = channel
+    out_memview32i = out
+    _average_pooling_2x2_single_mip[int32_t](&arr_memview32i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview32i[0,0,0,0,0], bool(sparse))
+  elif channel.dtype == np.int64:
+    arr_memview64i = channel
+    out_memview64i = out
+    _average_pooling_2x2_single_mip[int64_t](&arr_memview64i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview64i[0,0,0,0,0], bool(sparse))
   elif channel.dtype == np.float32:
     arr_memviewf = channel
     out_memviewf = out
@@ -230,6 +262,142 @@ def _average_pooling_2x2_uint8(np.ndarray[uint8_t, ndim=5] channel, uint32_t num
 
   return results
 
+def _average_pooling_2x2_int8(np.ndarray[int8_t, ndim=5] channel, uint32_t num_mips, sparse):
+  cdef size_t sx = channel.shape[0]
+  cdef size_t sy = channel.shape[1]
+  cdef size_t sz = channel.shape[2]
+  cdef size_t sw = channel.shape[3]
+  cdef size_t sv = channel.shape[4]
+  cdef size_t sxy = sx * sy
+
+  cdef size_t osx = (sx + 1) // 2
+  cdef size_t osy = (sy + 1) // 2
+  cdef size_t osxy = osx * osy
+  cdef size_t ovoxels = osxy * sz * sw * sv
+
+  cdef int8_t[:,:,:,:,:] channelview = channel
+  cdef int16_t* accum = accumulate_2x2[int8_t, int16_t](&channelview[0,0,0,0,0], sx, sy, sz, sw, sv)
+  cdef int16_t[:] accumview = <int16_t[:ovoxels]>accum
+  cdef int16_t* tmp
+  cdef uint32_t mip, bitshift
+
+  cdef int16_t* denominator
+  if sparse:
+    denominator = denominator_2x2[int8_t, int16_t](&channelview[0,0,0,0,0], sx, sy, sz, sw, sv)
+
+  cdef int8_t[:] oimgview
+
+  results = []
+  for mip in range(num_mips):
+    bitshift = 2 * ((mip % 4) + 1) # integer truncation every 4 mip levels
+    oimg = np.zeros( (ovoxels,), dtype=np.int8, order='F')
+    oimgview = oimg
+
+    if sparse:
+      render_image_sparse[int16_t, int8_t](&accumview[0], denominator, &oimgview[0], ovoxels)
+    else:
+      render_image[int16_t, int8_t](&accumview[0], &oimgview[0], bitshift, ovoxels)
+
+    results.append(
+      oimg.reshape( (osx, osy, sz, sw, sv), order='F' )
+    )
+
+    if mip == num_mips - 1:
+      break
+
+    if bitshift == 8:
+      shift_right[int16_t](accum, ovoxels, bitshift)
+
+    sx = osx 
+    sy = osy 
+    sxy = sx * sy
+    osx = (sx + 1) // 2
+    osy = (sy + 1) // 2
+    osxy = osx * osy
+    ovoxels = osxy * sz * sw * sv
+
+    tmp = accum 
+    accum = accumulate_2x2[int16_t, int16_t](accum, sx, sy, sz, sw, sv)
+    accumview = <int16_t[:ovoxels]>accum
+    PyMem_Free(tmp)
+
+    if sparse:
+      tmp = denominator
+      denominator = accumulate_2x2[int16_t, int16_t](denominator, sx, sy, sz, sw, sv)
+      PyMem_Free(tmp)
+
+  PyMem_Free(accum)
+
+  return results
+
+def _average_pooling_2x2_int16(np.ndarray[int16_t, ndim=5] channel, uint32_t num_mips, sparse):
+  cdef size_t sx = channel.shape[0]
+  cdef size_t sy = channel.shape[1]
+  cdef size_t sz = channel.shape[2]
+  cdef size_t sw = channel.shape[3]
+  cdef size_t sv = channel.shape[4]
+  cdef size_t sxy = sx * sy
+
+  cdef size_t osx = (sx + 1) // 2
+  cdef size_t osy = (sy + 1) // 2
+  cdef size_t osxy = osx * osy
+  cdef size_t ovoxels = osxy * sz * sw * sv
+
+  cdef int16_t[:,:,:,:,:] channelview = channel
+  cdef int32_t* accum = accumulate_2x2[int16_t, int32_t](&channelview[0,0,0,0,0], sx, sy, sz, sw, sv)
+  cdef int32_t[:] accumview = <int32_t[:ovoxels]>accum
+  cdef int32_t* tmp
+  cdef uint32_t mip, bitshift
+
+  cdef int32_t* denominator
+  if sparse:
+    denominator = denominator_2x2[int16_t, int32_t](&channelview[0,0,0,0,0], sx, sy, sz, sw, sv)
+
+  cdef int16_t[:] oimgview
+
+  results = []
+  for mip in range(num_mips):
+    bitshift = 2 * ((mip % 4) + 1) # integer truncation every 4 mip levels
+    oimg = np.zeros( (ovoxels,), dtype=np.int16, order='F')
+    oimgview = oimg
+
+    if sparse:
+      render_image_sparse[int32_t, int16_t](&accumview[0], denominator, &oimgview[0], ovoxels)
+    else:
+      render_image[int32_t, int16_t](&accumview[0], &oimgview[0], bitshift, ovoxels)
+
+    results.append(
+      oimg.reshape( (osx, osy, sz, sw, sv), order='F' )
+    )
+
+    if mip == num_mips - 1:
+      break
+
+    if bitshift == 8:
+      shift_right[int32_t](accum, ovoxels, bitshift)
+
+    sx = osx 
+    sy = osy 
+    sxy = sx * sy
+    osx = (sx + 1) // 2
+    osy = (sy + 1) // 2
+    osxy = osx * osy
+    ovoxels = osxy * sz * sw * sv
+
+    tmp = accum 
+    accum = accumulate_2x2[int32_t, int32_t](accum, sx, sy, sz, sw, sv)
+    accumview = <int32_t[:ovoxels]>accum
+    PyMem_Free(tmp)
+
+    if sparse:
+      tmp = denominator
+      denominator = accumulate_2x2[int32_t, int32_t](denominator, sx, sy, sz, sw, sv)
+      PyMem_Free(tmp)
+
+  PyMem_Free(accum)
+
+  return results
+
 def _average_pooling_2x2_uint16(np.ndarray[uint16_t, ndim=5] channel, uint32_t num_mips, sparse):
   cdef size_t sx = channel.shape[0]
   cdef size_t sy = channel.shape[1]
@@ -451,8 +619,12 @@ def average_pooling_2x2x2(channel, size_t num_mips=1, sparse=False):
     results = _average_pooling_2x2x2_single_mip_py(channel)
   elif channel.dtype == np.uint8:
     results = _average_pooling_2x2x2_uint8(channel, num_mips, sparse)
+  elif channel.dtype == np.int8:
+    results = _average_pooling_2x2x2_int8(channel, num_mips, sparse)
   elif channel.dtype == np.uint16:
     results = _average_pooling_2x2x2_uint16(channel, num_mips, sparse)
+  elif channel.dtype == np.int16:
+    results = _average_pooling_2x2x2_int16(channel, num_mips, sparse)
   elif channel.dtype == np.float32:
     results = _average_pooling_2x2x2_float(channel, num_mips)
   elif channel.dtype == np.float64:
@@ -466,6 +638,8 @@ def average_pooling_2x2x2(channel, size_t num_mips=1, sparse=False):
   return results
 
 def _average_pooling_2x2x2_single_mip_py(np.ndarray[NUMBER, ndim=5] channel):
+  cdef int8_t[:,:,:,:,:] arr_memview8i
+  cdef int16_t[:,:,:,:,:] arr_memview16i
   cdef uint8_t[:,:,:,:,:] arr_memview8u
   cdef uint16_t[:,:,:,:,:] arr_memview16u
   cdef uint32_t[:,:,:,:,:] arr_memview32u
@@ -473,6 +647,8 @@ def _average_pooling_2x2x2_single_mip_py(np.ndarray[NUMBER, ndim=5] channel):
   cdef float[:,:,:,:,:] arr_memviewf
   cdef double[:,:,:,:,:] arr_memviewd
 
+  cdef int8_t[:,:,:,:,:] out_memview8i
+  cdef int16_t[:,:,:,:,:] out_memview16i
   cdef uint8_t[:,:,:,:,:] out_memview8u
   cdef uint16_t[:,:,:,:,:] out_memview16u
   cdef uint32_t[:,:,:,:,:] out_memview32u
@@ -494,10 +670,18 @@ def _average_pooling_2x2x2_single_mip_py(np.ndarray[NUMBER, ndim=5] channel):
     arr_memview8u = channel
     out_memview8u = out
     _average_pooling_2x2x2_single_mip[uint8_t](&arr_memview8u[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview8u[0,0,0,0,0])
+  elif channel.dtype == np.int8:
+    arr_memview8i = channel
+    out_memview8i = out
+    _average_pooling_2x2x2_single_mip[int8_t](&arr_memview8i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview8i[0,0,0,0,0])
   elif channel.dtype == np.uint16:
     arr_memview16u = channel
     out_memview16u = out
     _average_pooling_2x2x2_single_mip[uint16_t](&arr_memview16u[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview16u[0,0,0,0,0])
+  elif channel.dtype == np.int16:
+    arr_memview16i = channel
+    out_memview16i = out
+    _average_pooling_2x2x2_single_mip[int16_t](&arr_memview16i[0,0,0,0,0], sx, sy, sz, sw, sv, &out_memview16i[0,0,0,0,0])
   elif channel.dtype == np.uint32:
     arr_memview32u = channel
     out_memview32u = out
@@ -603,6 +787,90 @@ def _average_pooling_2x2x2_uint8(np.ndarray[uint8_t, ndim=5] channel, uint32_t n
 
   return results
 
+def _average_pooling_2x2x2_int8(np.ndarray[int8_t, ndim=5] channel, uint32_t num_mips, sparse=False):
+  cdef size_t sx = channel.shape[0]
+  cdef size_t sy = channel.shape[1]
+  cdef size_t sz = channel.shape[2]
+  cdef size_t sw = channel.shape[3]
+  cdef size_t sv = channel.shape[4]
+  cdef size_t sxy = sx * sy
+
+  cdef size_t osx = (sx + 1) // 2
+  cdef size_t osy = (sy + 1) // 2
+  cdef size_t osz = (sz + 1) // 2
+  cdef size_t osxy = osx * osy
+  cdef size_t ovoxels = osxy * osz * sw * sv
+
+  cdef int8_t[:,:,:,:,:] channelview = channel
+  cdef int32_t* accum = accumulate_2x2x2[int8_t, int32_t](
+    &channelview[0,0,0,0,0], sx, sy, sz, sw, sv
+  )
+  cdef int32_t[:] accumview = <int32_t[:ovoxels]>accum
+
+  # "denominator"
+  cdef int32_t* denom
+  cdef int32_t[:] denomview
+  if sparse:
+    denom = denominator_2x2x2[int8_t, int32_t](
+      &channelview[0,0,0,0,0], sx, sy, sz, sw, sv
+    )
+    denomview = <int32_t[:ovoxels]>denom
+
+  cdef int32_t* tmp
+  cdef uint32_t mip, bitshift
+
+  cdef int8_t[:] oimgview
+
+  results = []
+  for mip in range(num_mips):
+    bitshift = 3 * ((mip % 8) + 1) # integer truncation every 8 mip levels
+    oimg = np.zeros( (ovoxels,), dtype=np.int8, order='F')
+    oimgview = oimg
+
+    if sparse:
+      render_image_sparse[int32_t, int8_t](&accumview[0], &denomview[0], &oimgview[0], ovoxels)
+    else:
+      render_image[int32_t, int8_t](&accumview[0], &oimgview[0], bitshift, ovoxels)
+
+    results.append(
+      oimg.reshape( (osx, osy, osz, sw), order='F' )
+    )
+
+    if mip == num_mips - 1:
+      break
+
+    if bitshift == 24:
+      shift_right[int32_t](accum, ovoxels, bitshift)
+      if sparse:
+        shift_right[int32_t](denom, ovoxels, bitshift)
+
+    sx = osx 
+    sy = osy 
+    sz = osz
+    sxy = sx * sy
+    osx = (sx + 1) // 2
+    osy = (sy + 1) // 2
+    osz = (sz + 1) // 2
+    osxy = osx * osy
+    ovoxels = osxy * osz * sw * sv
+
+    tmp = accum 
+    accum = accumulate_2x2x2[int32_t, int32_t](accum, sx, sy, sz, sw, sv)
+    accumview = <int32_t[:ovoxels]>accum
+    PyMem_Free(tmp)
+
+    if sparse:
+      tmp = denom
+      denom = accumulate_2x2x2[int32_t, int32_t](denom, sx, sy, sz, sw, sv)
+      denomview = <int32_t[:ovoxels]>denom
+      PyMem_Free(tmp)
+
+  PyMem_Free(accum)
+  if sparse:
+    PyMem_Free(denom)
+
+  return results
+
 def _average_pooling_2x2x2_uint16(np.ndarray[uint16_t, ndim=5] channel, uint32_t num_mips, sparse):
   cdef size_t sx = channel.shape[0]
   cdef size_t sy = channel.shape[1]
@@ -686,6 +954,89 @@ def _average_pooling_2x2x2_uint16(np.ndarray[uint16_t, ndim=5] channel, uint32_t
 
   return results
 
+def _average_pooling_2x2x2_int16(np.ndarray[int16_t, ndim=5] channel, uint32_t num_mips, sparse):
+  cdef size_t sx = channel.shape[0]
+  cdef size_t sy = channel.shape[1]
+  cdef size_t sz = channel.shape[2]
+  cdef size_t sw = channel.shape[3]
+  cdef size_t sv = channel.shape[4]
+  cdef size_t sxy = sx * sy
+
+  cdef size_t osx = (sx + 1) // 2
+  cdef size_t osy = (sy + 1) // 2
+  cdef size_t osz = (sz + 1) // 2
+  cdef size_t osxy = osx * osy
+  cdef size_t ovoxels = osxy * osz * sw * sv
+
+  cdef int16_t[:,:,:,:,:] channelview = channel
+  cdef int32_t* accum = accumulate_2x2x2[int16_t, int32_t](
+    &channelview[0,0,0,0,0], sx, sy, sz, sw, sv
+  )
+  cdef int32_t[:] accumview = <int32_t[:ovoxels]>accum
+
+  # "denominator"
+  cdef int32_t* denom
+  cdef int32_t[:] denomview
+  if sparse:
+    denom = denominator_2x2x2[int16_t, int32_t](
+      &channelview[0,0,0,0,0], sx, sy, sz, sw, sv
+    )
+    denomview = <int32_t[:ovoxels]>denom
+
+  cdef int32_t* tmp
+  cdef uint32_t mip, bitshift
+
+  cdef int16_t[:] oimgview
+
+  results = []
+  for mip in range(num_mips):
+    bitshift = 3 * ((mip % 5) + 1) # integer truncation every 5 mip levels
+    oimg = np.zeros( (ovoxels,), dtype=np.uint16, order='F')
+    oimgview = oimg
+    if sparse:
+      render_image_sparse[int32_t, int16_t](&accumview[0], &denomview[0], &oimgview[0], ovoxels)
+    else:
+      render_image[int32_t, int16_t](&accumview[0], &oimgview[0], bitshift, ovoxels)
+
+    results.append(
+      oimg.reshape( (osx, osy, osz, sw, sv), order='F' )
+    )
+
+    if mip == num_mips - 1:
+      break
+
+    if bitshift == 15:
+      shift_right[int32_t](accum, ovoxels, bitshift)
+      if sparse:
+        shift_right[int32_t](denom, ovoxels, bitshift)
+
+    sx = osx 
+    sy = osy 
+    sz = osz
+    sxy = sx * sy
+    osx = (sx + 1) // 2
+    osy = (sy + 1) // 2
+    osz = (sz + 1) // 2
+    osxy = osx * osy
+    ovoxels = osxy * osz * sw * sv
+
+    tmp = accum 
+    accum = accumulate_2x2x2[int32_t, int32_t](accum, sx, sy, sz, sw, sv)
+    accumview = <int32_t[:ovoxels]>accum
+    PyMem_Free(tmp)
+
+    if sparse:
+      tmp = denom
+      denom = accumulate_2x2x2[int32_t, int32_t](denom, sx, sy, sz, sw, sv)
+      denomview = <int32_t[:ovoxels]>denom
+      PyMem_Free(tmp)
+
+  PyMem_Free(accum)
+  if sparse:
+    PyMem_Free(denom)
+
+  return results
+
 def _average_pooling_2x2x2_float(np.ndarray[float, ndim=5] channel, uint32_t num_mips):
   cdef size_t sx = channel.shape[0]
   cdef size_t sy = channel.shape[1]

{tinybrain-1.6.0 → tinybrain-1.8.0}/tinybrain/downsample.py

@@ -45,7 +45,7 @@ def downsample_with_averaging(img, factor, num_mips=1, sparse=False):
   Returns: [ mip0, mip1, mip2, ..., num_mip ]
   """
   if (
-    img.dtype in (np.uint8, np.uint16, np.float32, np.float64)
+    img.dtype in (np.int8, np.int16, np.uint8, np.uint16, np.float32, np.float64)
     or num_mips == 1 # _average_pooling_2x2_single_mip_py supports all primative types
   ):
     img = np.asfortranarray(img)
@@ -136,7 +136,7 @@ def downsample_with_averaging_numpy(array, factor, sparse=False):
     indexing_expr = tuple(np.s_[:s] for s in part.shape)
     temp[indexing_expr] += part
     if sparse:
-      counts[indexing_expr] += part > 0
+      counts[indexing_expr] += part != 0
     else:
       counts[indexing_expr] += 1
 
@@ -230,6 +230,11 @@ def downsample_segmentation(img, factor, sparse=False, num_mips=1):
   if np.all(np.array(factor, int) == 1):
       return [ img ] * num_mips
 
+  binary_image = isinstance(img, (bool, np.bool_))
+
+  if binary_image:
+    img = img.view(np.uint8)
+
   if tuple(factor) in ( (2,2), (2,2,1), (2,2,1,1) ) and not sparse:
     return tinybrain.accelerated.mode_pooling_2x2(img, num_mips=num_mips)
   elif tuple(factor) in ( (2,2,2), (2,2,2,1) ):
@@ -244,6 +249,10 @@ def downsample_segmentation(img, factor, sparse=False, num_mips=1):
     results.append(img)
 
   results = [ squeeze_dims(img, ndim) for img in results ]
+
+  if binary_image:
+    results = [ mip_img.view(bool) for mip_img in results ]
+
   return results
 
 def _downsample_segmentation(data, factor, sparse=False):

{tinybrain-1.6.0 → tinybrain-1.8.0}/tinybrain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: tinybrain
-Version: 1.6.0
+Version: 1.8.0
 Summary: Image pyramid generation specialized for connectomics data types and procedures.
 Home-page: https://github.com/seung-lab/tinybrain/
 Author: William Silversmith
@@ -9,19 +9,28 @@ Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 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: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: numpy
-
-[![Build Status](https://travis-ci.org/seung-lab/tinybrain.svg?branch=master)](https://travis-ci.org/seung-lab/tinybrain) [![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![PyPI version](https://badge.fury.io/py/tinybrain.svg)](https://badge.fury.io/py/tinybrain)  
 
 # tinybrain
 
@@ -37,7 +46,12 @@ img = load_3d_em_stack()
 img_pyramid = tinybrain.downsample_with_averaging(img, factor=(2,2,1), num_mips=5, sparse=False)
 
 labels = load_3d_labels()
-label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False))
+label_pyramid = tinybrain.downsample_segmentation(labels, factor=(2,2,1), num_mips=5, sparse=False)
+
+# We also have a few other types
+img_pyramid = tinybrain.downsample_with_min_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_max_pooling(image, factor=(2,2,1), num_mips=5)
+img_pyramid = tinybrain.downsample_with_striding(image, factor=(2,2,1), num_mips=5)
 ```
 
 ## Installation 
@@ -50,7 +64,7 @@ pip install tinybrain
 ## Motivation
 
 Image hierarchy generation in connectomics uses a few different techniques for
-visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualze upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
+visualizing data, but predominantly we create image pyramids of uint8 grayscale images using 2x2 average pooling and of uint8 to uint64 segmentation labels using 2x2 mode pooling. When images become very large and people wish to visualize upper mip levels using three axes at once, it becomes desirable to perform 2x2x2 downsamples to maintain isotropy.
 
 It's possible to compute both of these using numpy, however as multiple packages found it useful to copy the downsample functions, it makes sense to formalize these functions into a seperate library located on PyPI.
 

tinybrain-1.8.0/tinybrain.egg-info/pbr.json

@@ -0,0 +1 @@
+{"git_version": "c656201", "is_release": true}

tinybrain-1.6.0/.github/workflows/build_wheel.yml

@@ -1,39 +0,0 @@
-name: Build Wheels
-
-on:
-  workflow_dispatch:
-  push:
-    tags:
-      - '*'
-env:
-  CIBW_SKIP: pp* *-musllinux*
-
-jobs:
-  build_wheels:
-    name: Build wheels on ${{matrix.arch}} for ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-2019, macos-latest]
-        arch: [auto]
-        include:
-          - os: ubuntu-latest
-            arch: aarch64
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up QEMU
-        if:  ${{ matrix.arch == 'aarch64' }}
-        uses: docker/setup-qemu-action@v1
-
-      - name: Build wheels
-        uses: pypa/cibuildwheel@v2.19.1
-        # to supply options, put them in 'env', like:
-        env:
-          CIBW_ARCHS_LINUX: ${{matrix.arch}}
-          CIBW_BEFORE_BUILD: pip install numpy setuptools wheel cython
-
-      - uses: actions/upload-artifact@v2
-        with:
-          path: ./wheelhouse/*.whl

tinybrain-1.6.0/tinybrain.egg-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "3539c4e", "is_release": true}