dcnum 0.11.0__py3-none-any.whl → 0.11.2__py3-none-any.whl

dcnum/_version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.11.0'
-__version_tuple__ = version_tuple = (0, 11, 0)
+__version__ = version = '0.11.2'
+__version_tuple__ = version_tuple = (0, 11, 2)

dcnum/feat/event_extractor_manager_thread.py

@@ -65,7 +65,8 @@ class EventExtractorManagerThread(threading.Thread):
         self.label_array = np.ctypeslib.as_array(
             self.fe_kwargs["label_array"]).reshape(
             self.data.image.chunk_shape)
-
+        #: Time counter for feature extraction
+        self.t_count = 0
         #: Whether debugging is enabled
         self.debug = debug
 
@@ -100,6 +101,8 @@ class EventExtractorManagerThread(threading.Thread):
                     unavailable_slots = 0
                     time.sleep(.1)
 
+            t1 = time.monotonic()
+
             # We have a chunk, process it!
             chunk = self.slot_chunks[cur_slot]
             # Populate the labeling array for the workers
@@ -123,8 +126,10 @@ class EventExtractorManagerThread(threading.Thread):
             self.slot_states[cur_slot] = "w"
 
             self.logger.debug(f"Extracted one chunk: {chunk}")
+            self.t_count += time.monotonic() - t1
 
             chunks_processed += 1
+
             if chunks_processed == self.data.image.num_chunks:
                 break
 
@@ -132,3 +137,4 @@ class EventExtractorManagerThread(threading.Thread):
         self.fe_kwargs["finalize_extraction"].value = True
         [w.join() for w in workers]
         self.logger.debug("Finished extraction.")
+        self.logger.info(f"Extraction time: {self.t_count:.1f}s")

dcnum/feat/feat_moments/mt_legacy.py

@@ -10,22 +10,25 @@ def moments_based_features(mask, pixel_size):
 
     size = mask.shape[0]
 
-    deform = np.zeros(size, dtype=float)
-    size_x = np.zeros(size, dtype=float)
-    size_y = np.zeros(size, dtype=float)
-    pos_x = np.zeros(size, dtype=float)
-    pos_y = np.zeros(size, dtype=float)
-    area_msd = np.zeros(size, dtype=float)
-    area_ratio = np.zeros(size, dtype=float)
-    area_um = np.zeros(size, dtype=float)
-    aspect = np.zeros(size, dtype=float)
-    tilt = np.zeros(size, dtype=float)
-    inert_ratio_cvx = np.zeros(size, dtype=float)
-    inert_ratio_raw = np.zeros(size, dtype=float)
-    inert_ratio_prnc = np.zeros(size, dtype=float)
+    empty = np.full(size, np.nan, dtype=np.float64)
+    deform = np.copy(empty)
+    size_x = np.copy(empty)
+    size_y = np.copy(empty)
+    pos_x = np.copy(empty)
+    pos_y = np.copy(empty)
+    area_msd = np.copy(empty)
+    area_ratio = np.copy(empty)
+    area_um = np.copy(empty)
+    aspect = np.copy(empty)
+    tilt = np.copy(empty)
+    inert_ratio_cvx = np.copy(empty)
+    inert_ratio_raw = np.copy(empty)
+    inert_ratio_prnc = np.copy(empty)
 
     for ii in range(size):
         cont_raw = contour_single_opencv(mask[ii])
+        if len(cont_raw.shape) < 2:
+            continue
         mu_raw = cv2.moments(cont_raw)
 
         # convex hull

dcnum/feat/feat_texture/tex_all.py

@@ -4,16 +4,16 @@ import numpy as np
 from .common import haralick_names
 
 
-def haralick_texture_features(image, mask, image_bg=None, image_corr=None):
+def haralick_texture_features(
+        mask, image=None, image_bg=None, image_corr=None):
     # make sure we have a boolean array
     mask = np.array(mask, dtype=bool)
     size = mask.shape[0]
 
     # compute features if necessary
-    if image_bg is not None or image_corr is not None:
+    if image_bg is not None and image is not None and image_corr is None:
         # Background-corrected brightness values
-        if image_corr is None:
-            image_corr = np.array(image, dtype=np.int16) - image_bg
+        image_corr = np.array(image, dtype=np.int16) - image_bg
 
     tex_dict = {}
     empty = np.full(size, np.nan, dtype=np.float64)
@@ -29,6 +29,9 @@ def haralick_texture_features(image, mask, image_bg=None, image_corr=None):
         #   -> maximum value should be as small as possible
         # - set pixels outside contour to zero (ignored areas, see mahotas)
         maski = mask[ii]
+        if not np.any(maski):
+            # The mask is empty (nan values)
+            continue
         if image_corr.shape[0] == 1:
             # We have several masks for one image.
             imcoi = image_corr[0]

dcnum/meta/ppid.py

@@ -8,7 +8,7 @@ import pathlib
 
 #: Increment this string if there are breaking changes that make
 #: previous pipelines unreproducible.
-DCNUM_PPID_GENERATION = "2"
+DCNUM_PPID_GENERATION = "3"
 
 
 def compute_pipeline_hash(bg_id, seg_id, feat_id, gate_id,

dcnum/read/hdf5_data.py

@@ -31,9 +31,6 @@ class HDF5Data:
         if isinstance(path, h5py.File):
             self.h5 = path
             path = path.filename
-        else:
-            self.h5 = None  # is set in __setstate__
-        self._cache_scalar = {}
         self.__setstate__({"path": path,
                            "pixel_size": pixel_size,
                            "md5_5m": md5_5m,
@@ -69,7 +66,25 @@ class HDF5Data:
             warnings.warn(f"Feature {feat} not cached (possibly slow)")
             return self.h5["events"][feat]
 
+    def __getstate__(self):
+        return {"path": self.path,
+                "pixel_size": self.pixel_size,
+                "md5_5m": self.md5_5m,
+                "meta": self.meta,
+                "logs": self.logs,
+                "tables": self.tables,
+                "image_cache_size": self.image.cache_size
+                }
+
     def __setstate__(self, state):
+        # Make sure these properties exist (we rely on __init__, because
+        # we want this class to be pickable and __init__ is not called by
+        # `pickle.load`.
+        if not hasattr(self, "_cache_scalar"):
+            self._cache_scalar = {}
+        if not hasattr(self, "h5"):
+            self.h5 = None
+
         self.path = state["path"]
 
         self.md5_5m = state["md5_5m"]
@@ -100,7 +115,10 @@ class HDF5Data:
                         alog = [ll.decode("utf") for ll in alog]
                     self.logs[key] = alog
                 for tab in h5.get("tables", []):
-                    self.tables[tab] = h5["tables"][key][:]
+                    tabdict = {}
+                    for tkey in h5["tables"][tab].dtype.fields.keys():
+                        tabdict[tkey] = h5["tables"][tab][tkey]
+                    self.tables[tab] = tabdict
 
         if state["pixel_size"] is not None:
             self.pixel_size = state["pixel_size"]
@@ -137,15 +155,6 @@ class HDF5Data:
 
         self.image_corr = ImageCorrCache(self.image, self.image_bg)
 
-    def __getstate__(self):
-        return {"path": self.path,
-                "pixel_size": self.pixel_size,
-                "md5_5m": self.md5_5m,
-                "meta": self.meta,
-                "logs": self.logs,
-                "tables": self.tables,
-                }
-
     @functools.cache
     def __len__(self):
         return self.h5.attrs["experiment:event count"]

dcnum/segm/segmenter.py

@@ -173,11 +173,13 @@ class Segmenter(abc.ABC):
             labels_uint8 = np.array(labels, dtype=np.uint8)
             labels_dilated = cv2.dilate(labels_uint8, element)
             labels_eroded = cv2.erode(labels_dilated, element)
-            labels, _ = ndi.label(labels_eroded > 0)
+            labels, _ = ndi.label(
+                input=labels_eroded > 0,
+                structure=ndi.generate_binary_structure(2, 2))
 
         if fill_holes:
             # Floodfill only works with uint8 (too small) or int32
-            if not labels.dtype == np.int32:
+            if labels.dtype != np.int32:
                 labels = np.array(labels, dtype=np.int32)
             #
             # from scipy import ndimage
@@ -206,7 +208,7 @@ class Segmenter(abc.ABC):
         mol = segm_wrap(image)
         if mol.dtype == bool:
             # convert mask to label
-            labels, num_labels = ndi.label(
+            labels, _ = ndi.label(
                 input=mol,
                 structure=ndi.generate_binary_structure(2, 2))
         else:

dcnum/segm/segmenter_cpu.py

@@ -31,6 +31,12 @@ class CPUSegmenter(Segmenter, abc.ABC):
         # Tells the workers to stop
         self.mp_shutdown = mp.Value("i", 0)
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.join_workers()
+
     def __getstate__(self):
         # Copy the object's state from self.__dict__ which contains
         # all our instance attributes. Always use the dict.copy()
@@ -47,7 +53,7 @@ class CPUSegmenter(Segmenter, abc.ABC):
         return state
 
     def __setstate__(self, state):
-        # Restore instance attributes (i.e., filename and lineno).
+        # Restore instance attributes
         self.__dict__.update(state)
 
     @staticmethod

dcnum/segm/segmenter_gpu.py

@@ -2,6 +2,7 @@ import abc
 import pathlib
 
 import numpy as np
+import scipy.ndimage as ndi
 
 
 from .segmenter import Segmenter
@@ -10,7 +11,7 @@ from .segmenter import Segmenter
 class GPUSegmenter(Segmenter, abc.ABC):
     mask_postprocessing = False
 
-    def __init__(self, model_file, *args, **kwargs):
+    def __init__(self, model_file=None, *args, **kwargs):
         super(GPUSegmenter, self).__init__(*args, **kwargs)
         self.model_path = self._get_model_path(model_file)
 
@@ -28,6 +29,18 @@ class GPUSegmenter(Segmenter, abc.ABC):
             stop = len(image_data)
 
         image_slice = image_data[start:stop]
-        segm = self.segment_frame_wrapper(self.model_path)
+        segm = self.segment_frame_wrapper()
 
-        return segm(image_slice)
+        labels = segm(image_slice)
+
+        # Make sure we have integer labels
+        if labels.dtype == bool:
+            new_labels = np.zeros_like(labels, dtype=np.uint16)
+            for ii in range(len(labels)):
+                ndi.label(
+                    input=labels[ii],
+                    output=new_labels[ii],
+                    structure=ndi.generate_binary_structure(2, 2))
+            labels = new_labels
+
+        return labels

dcnum/segm/segmenter_manager_thread.py

@@ -71,6 +71,8 @@ class SegmenterManagerThread(threading.Thread):
         self.slot_chunks = slot_chunks
         #: List containing the segmented labels of each slot
         self.labels_list = [None] * len(self.slot_states)
+        #: Time counter for segmentation
+        self.t_count = 0
         #: Whether running in debugging mode
         self.debug = debug
 
@@ -96,6 +98,8 @@ class SegmenterManagerThread(threading.Thread):
                     empty_slots = 0
                     time.sleep(.01)
 
+            t1 = time.monotonic()
+
             # We have a free slot to compute the segmentation
             labels = self.segmenter.segment_chunk(
                 image_data=self.image_data,
@@ -111,7 +115,11 @@ class SegmenterManagerThread(threading.Thread):
             self.slot_states[cur_slot] = "e"
             self.logger.debug(f"Segmented one chunk: {chunk}")
 
+            self.t_count += time.monotonic() - t1
+
         # Cleanup
         if isinstance(self.segmenter, CPUSegmenter):
             # Join the segmentation workers.
             self.segmenter.join_workers()
+
+        self.logger.info(f"Segmentation time: {self.t_count:.1f}s")

{dcnum-0.11.0.dist-info → dcnum-0.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.11.0
+Version: 0.11.2
 Summary: numerics toolbox for imaging deformability cytometry
 Author: Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>

{dcnum-0.11.0.dist-info → dcnum-0.11.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=Zl7Bo-WQiiNZwnp-zeuyFKzcZ9ykPaawnk_0wuzNx2I,162
+dcnum/_version.py,sha256=jNTsW7w_cV00kI4XQuVNdxy3zty3vBGoedJmCKxUwlo,162
 dcnum/feat/__init__.py,sha256=0oX765AyfL1BcVt-FI6R_i6x5LgYYLeyO5lkxSauI0Y,299
-dcnum/feat/event_extractor_manager_thread.py,sha256=lu0Xw64JiSRYMPRnW7GJQwuX56mfELZaZ7DOqUYIrcQ,5458
+dcnum/feat/event_extractor_manager_thread.py,sha256=54eCKbLBkv3U7RLGfqtiMB1CnqHNKcTm9vJE84qu9X8,5681
 dcnum/feat/gate.py,sha256=UEHbj3hkMWNm4tlY8Tz8sOsruhByjJxgO1s-ztQ7WTw,6235
 dcnum/feat/queue_event_extractor.py,sha256=_CwtEcJ-zzChkiPbRHC-WdVNy9sNWOYTzZPd2oEvtrU,11493
 dcnum/feat/feat_background/__init__.py,sha256=mL8QJYK6m3hxTqF6Cuosu__Fm5tZUMa-hTgSGcNw9AE,458
@@ -13,22 +13,22 @@ dcnum/feat/feat_brightness/bright_all.py,sha256=Z5b-xkw7g7ejMpbGmdUqrxGRymqFhAQs
 dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
 dcnum/feat/feat_moments/__init__.py,sha256=RxDTbl-XVVk8HIgihTuqWdmD0ciNGdfg715ShHEGUHs,68
 dcnum/feat/feat_moments/ct_opencv.py,sha256=_qyHCGvylVxruMWafvVbVOzhWGXLoFi10LReNxGcWhY,463
-dcnum/feat/feat_moments/mt_legacy.py,sha256=O4Zzu9L8dmdQ-H4dV0WrUTY9ZahKDVnoT40cgztYeuQ,3469
+dcnum/feat/feat_moments/mt_legacy.py,sha256=Z6h2ag3SmOVWT9nRtKg7EqqvS4RBOnKrLm2P1Sm51aY,3409
 dcnum/feat/feat_texture/__init__.py,sha256=SjYRb917PrFN231M2nVxq12DDH2y72WocsS9yY7xqaI,84
 dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
-dcnum/feat/feat_texture/tex_all.py,sha256=Rxn0KJc8zuii5gc8bjdsz90cwZ1q43mA7aZ9Zi5ZqXg,4003
+dcnum/feat/feat_texture/tex_all.py,sha256=eGjjNfPpfZw7FA_VNFCIMiU38KD0qcGbxLciYy-tCiA,4097
 dcnum/meta/__init__.py,sha256=cQT_HN5yDKzMnZM8CUyNmeA68OhE3ENO_rvFmgDj95c,40
-dcnum/meta/ppid.py,sha256=gcp93OGCMRHHQ6C0EWvjZC7CjeEDMv0aKO8Mp45V6ig,5951
+dcnum/meta/ppid.py,sha256=YZD2ErfnShLsJDKZOWQg298Nmk2okuwzqOMUrlJ5nSo,5951
 dcnum/read/__init__.py,sha256=iV2wrBMdwJgpXaphNiiAVybndDzTTv0CAGRNXyvxcLY,157
 dcnum/read/cache.py,sha256=mr2DBJZYgNIAiz64TQ4cgkPmRt8nJWBvgkOpaz-p6Yg,5467
 dcnum/read/const.py,sha256=SVlvEJiRIHyTyUlWG24_ogcnT5nTxCi0CRslNuNP56I,282
-dcnum/read/hdf5_data.py,sha256=vTft5pCaI4dr8kqclWDdA5vA7XFHnQ7GQcAGn7hx9KQ,11702
+dcnum/read/hdf5_data.py,sha256=qrkT7577zA86nnsaXiL_KqT0elVeDo8Uqj20jTyAnzo,12135
 dcnum/segm/__init__.py,sha256=BNFn7VvWsRmOzxCtvr4AXi3mmWsJSsQlEmGlq7umCac,510
 dcnum/segm/segm_thresh.py,sha256=fim5HRNWq0DUhVRwLf6nmu4gOHAFtydGDRS1Ww_XzFo,1134
-dcnum/segm/segmenter.py,sha256=dvCHFkxk-Xe5UupgJ609NK2iDB9BkyXBc6OVYBRghIg,8929
-dcnum/segm/segmenter_cpu.py,sha256=O9t9SYenZz8Cbu9FIAxv8uU8cebQVUp1Abe4Rf53tKE,9626
-dcnum/segm/segmenter_gpu.py,sha256=LoFCjIW3-XQ79O0HJspJkDpIXc7qf3jTQz5jkFnkK24,879
-dcnum/segm/segmenter_manager_thread.py,sha256=-GsNJrljPOvDLRJLe0OB6AObQVIRo1xj5nnR_j-nOnA,4951
+dcnum/segm/segmenter.py,sha256=o5G9JnHG-dHnNwG8IdPK8MideF0IlSDbuYwCdrSr31w,9002
+dcnum/segm/segmenter_cpu.py,sha256=dJC6GCHVpTC5uDy0tieRfpO87weDdao-I9fIFub3_jU,9723
+dcnum/segm/segmenter_gpu.py,sha256=F-6H425eQc9B2-k5PURJziU5uQubdF96GTkoysD2JDM,1312
+dcnum/segm/segmenter_manager_thread.py,sha256=xtuk7gnk7xhoRoV_J97rrv7IR3JgeRvVewCDT-chqpk,5172
 dcnum/write/__init__.py,sha256=Oy-ORTyzUUswsaJvd0C6LyXtOgAY0iTIRqFNU9d7M8Y,160
 dcnum/write/deque_writer_thread.py,sha256=UUn5OYxDvckvhLw3llLYu7y8MI7RfsOhdJhMonKKB3k,1625
 dcnum/write/queue_collector_thread.py,sha256=Iw83KAcZu13elorHUOfJT6cVQntAKBLm6OVgkldjtL0,11088
@@ -37,25 +37,26 @@ docs/conf.py,sha256=VqB1WtClmmAVdfQ45SLa3aG7t6g2AcDG_BI6MO7j4wI,3022
 docs/index.rst,sha256=eWjHCDrw_VEC885Z3ON_wX5p2FRn_DI12WjSt0WcU5g,431
 docs/requirements.txt,sha256=KA1AT05zfznj2eE8ixs9cikcl_MtWplqbiXhp4h0YsI,87
 docs/extensions/github_changelog.py,sha256=SEJkjEvVtJ-42daYkNbcr9mHmmO6ZjDs6phvnySlNAE,2375
-tests/conftest.py,sha256=TwRBHM6NLOjnxoZNUVKdm7dWvkF_YfrQ0k1QajCyZaw,460
+tests/conftest.py,sha256=bYh2DmQRP2TbkmLBdeiKF-nSv5IX1oUNWcwT6w_bEUw,577
 tests/helper_methods.py,sha256=MsCppTICPqv4vq-DhUBIKFyOhvRO_oS2O0Fb3OYhNxs,1855
 tests/requirements.txt,sha256=Mfj5F30ZlweJpp9LC64TVta_lq6G5AINIfJxVxTK-2c,20
 tests/test_feat_background_bg_roll_median.py,sha256=FtrVcKumIctUrCWtNimGicExsouFxoZpbCwPnmeY1BU,4809
-tests/test_feat_brightness.py,sha256=OKlJzA0Y86TB410MTyt0ZJd8rBsobhN90A5HX2jXk88,1104
-tests/test_feat_haralick.py,sha256=RUSjL2fUHJjENd84Ef7MVCukzBxqU6XDiVpLyMbstjU,1068
-tests/test_feat_moments_based.py,sha256=V3duAIG7dJcHKLkLCq3deZW8rF0f9xfWKCtbrUUJrEo,1401
+tests/test_feat_brightness.py,sha256=V8F_zhxYvS0rrZl_SKZwVwpPLI6jq0J7NR-eOdNS6qg,2082
+tests/test_feat_haralick.py,sha256=_00p24WOzIOAtfKiXWcd8XoYBQKt3DbYdSijHZYzi64,3499
+tests/test_feat_moments_based.py,sha256=wRlqM8sGSPIzUB95gUuixNH1hTLgD7otj15-53CRxcE,3037
 tests/test_init.py,sha256=umUGuhCJ4iCsI5qjoNtrIAW_3xFfI3rDEGk8BKgzekc,73
 tests/test_ppid.py,sha256=gyrFLROG9IZIcHb0YQCHujTw-LdzGYTKZhJRAFgza6c,2785
 tests/test_ppid_segm.py,sha256=4NzGXns3lMetH970SKMnzizbnThx8ku4A1MiTozXMlA,238
 tests/test_read_concat_hdf5.py,sha256=jeOxG6T_Z8wtPVK_UbEa-X-VQtYdFCLE2oxFbWjN2iU,1951
-tests/test_read_hdf5.py,sha256=Np3Z4UQcztbdbI7THmA6IHDPLGLEjuy_MlIIy_f-PJI,5299
-tests/test_segm_thresh.py,sha256=1sh5HQq950VpLfDETrK79wqHKSL2afNeS9fxkee4AUA,11352
+tests/test_read_hdf5.py,sha256=v8o-jMp8ycDwF--7Qf1mQsRRU2V8RDlOwsiP4zUg6pg,6309
+tests/test_segm_thresh.py,sha256=ecHbhwy8_qVJTdpDJlo_sIiQPSIi_xKXM2EqUJXRU20,5101
+tests/test_segmenter.py,sha256=qjHTTUmaR08X4ATjndxJr9eZWFvpPQwJ_fSCw8-tr9Y,9307
 tests/test_write_deque_writer_thread.py,sha256=EAnqKayr4_jskv_599QYD3gdBZhtyVM7-MuqvtLHYAI,1140
 tests/test_write_writer.py,sha256=SzNTLsHz4RZceRwqflc4Wfn02vYc4Hb4WQVk1X8dmiw,1107
 tests/data/fmt-hdf5_cytoshot_full-features_2023.zip,sha256=LfkFxAXTIkcqxrJYYNMC364Q1x5HT5X9cTHuNz5eeuk,650653
 tests/data/fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip,sha256=z2Bk6u3wjr-bJa7sOxBcNKOQ0Zoi3Xmf_cMi6d-3CMk,154010
-dcnum-0.11.0.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.11.0.dist-info/METADATA,sha256=B2F6UhQaUvCBD_WQUNCoEj2YcptDKkaHhsey9cdJUhc,2180
-dcnum-0.11.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-dcnum-0.11.0.dist-info/top_level.txt,sha256=Utc_P-_-7hbtniTp00IsHTry4h3rY5KFmwHfYM9g44k,22
-dcnum-0.11.0.dist-info/RECORD,,
+dcnum-0.11.2.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.11.2.dist-info/METADATA,sha256=IY1M8PxGxukdhWm-_5bxwLw-rNqkBHduJLTGzt4bytA,2180
+dcnum-0.11.2.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+dcnum-0.11.2.dist-info/top_level.txt,sha256=Utc_P-_-7hbtniTp00IsHTry4h3rY5KFmwHfYM9g44k,22
+dcnum-0.11.2.dist-info/RECORD,,

tests/conftest.py

@@ -1,4 +1,5 @@
 import atexit
+import os
 import shutil
 import tempfile
 import time
@@ -15,3 +16,5 @@ def pytest_configure(config):
     """
     tempfile.tempdir = TMPDIR
     atexit.register(shutil.rmtree, TMPDIR, ignore_errors=True)
+    # Disable JIT compiler during testing for coverage
+    os.environ.setdefault("NUMBA_DISABLE_JIT", "1")

tests/test_feat_brightness.py

@@ -31,3 +31,26 @@ def test_basic_brightness():
         # control test
         assert not np.allclose(h5["events"]["bright_perc_10"][:],
                                data["bright_perc_90"])
+
+
+def test_basic_brightness_single_image():
+    # This original file was generated with dcevent for reference.
+    path = retrieve_data(data_path /
+                         "fmt-hdf5_cytoshot_full-features_2023.zip")
+    # Make data available
+    with h5py.File(path) as h5:
+        data = feat_brightness.brightness_features(
+            image=h5["events/image"][1][np.newaxis],
+            image_bg=h5["events/image_bg"][1][np.newaxis],
+            mask=h5["events/mask"][1][np.newaxis],
+        )
+
+        assert np.allclose(data["bright_bc_avg"][0],
+                           -43.75497215592681,
+                           atol=0, rtol=1e-10)
+        for feat in feat_brightness.brightness_names:
+            assert np.allclose(h5["events"][feat][1],
+                               data[feat][0]), f"Feature {feat} mismatch!"
+        # control test
+        assert not np.allclose(h5["events"]["bright_perc_10"][1],
+                               data["bright_perc_90"][0])

tests/test_feat_haralick.py

@@ -31,3 +31,90 @@ def test_basic_haralick():
         # control test
         assert not np.allclose(h5["events"]["tex_asm_avg"],
                                ret_arr["tex_asm_ptp"])
+
+
+def test_empty_image():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    image_corr = np.zeros(6*6, dtype=np.int16).reshape(1, 6, 6)
+    tex = feat_texture.haralick_texture_features(
+        image_corr=image_corr,
+        mask=masks,
+    )
+    assert np.allclose(tex["tex_con_avg"][0], 0)
+
+
+def test_empty_mask():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
+    tex = feat_texture.haralick_texture_features(
+        image_corr=image_corr,
+        mask=masks,
+    )
+    assert np.isnan(tex["tex_con_avg"][0])
+
+
+def test_1d_mask_image():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
+    tex = feat_texture.haralick_texture_features(
+        image_corr=image_corr,
+        mask=masks,
+    )
+    assert np.isnan(tex["tex_con_avg"][0])
+
+
+def test_nd_mask_with_1d_image():
+    mask = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)
+    masks = np.stack([mask, mask, mask, mask])
+    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
+    tex = feat_texture.haralick_texture_features(
+        image_corr=image_corr,
+        mask=masks,
+    )
+    assert len(tex["tex_con_avg"]) == 4
+    assert np.allclose(tex["tex_con_avg"][0], 27.75)
+
+
+def test_simple_mask_image():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    image_corr = np.arange(6*6, dtype=np.int16).reshape(1, 6, 6)
+    tex = feat_texture.haralick_texture_features(
+        image_corr=image_corr,
+        mask=masks,
+    )
+    assert np.allclose(tex["tex_con_avg"][0], 27.75)

tests/test_feat_moments_based.py

@@ -50,3 +50,59 @@ def test_moments_based_features():
         # control test
         assert not np.allclose(h5["events"]["inert_ratio_cvx"][:],
                                data["tilt"])
+
+
+def test_mask_0d():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    data = feat_moments.moments_based_features(
+                mask=masks,
+                pixel_size=0.2645
+            )
+    assert data["deform"].shape == (1,)
+    assert np.isnan(data["deform"][0])
+    assert np.isnan(data["area_um"][0])
+
+
+def test_mask_1d():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    data = feat_moments.moments_based_features(
+                mask=masks,
+                pixel_size=0.2645
+            )
+    assert data["deform"].shape == (1,)
+    assert np.isnan(data["deform"][0])
+    assert np.isnan(data["area_um"][0])
+
+
+def test_mask_2d():
+    masks = np.array([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0],
+    ], dtype=bool)[np.newaxis]
+    data = feat_moments.moments_based_features(
+                mask=masks,
+                pixel_size=0.2645
+            )
+    assert data["deform"].shape == (1,)
+    # This is the deformation of a square (compared to circle)
+    assert np.allclose(data["deform"][0], 0.11377307454724206)
+    # Without moments-based computation, this would be 4*pxsize=0.066125
+    assert np.allclose(data["area_um"][0], 0.06996025)

tests/test_read_hdf5.py

@@ -134,11 +134,8 @@ def test_pickling_state():
 
     h5d1 = read.HDF5Data(path)
     h5d1.pixel_size = 0.124
-    state = h5d1.__getstate__()
-    pstate = pickle.dumps(state)
-
-    state2 = pickle.loads(pstate)
-    h5d2 = read.HDF5Data(**state2)
+    pstate = pickle.dumps(h5d1)
+    h5d2 = pickle.loads(pstate)
     assert h5d1.md5_5m == h5d2.md5_5m
     assert h5d1.md5_5m == h5d2.md5_5m
     assert h5d1.pixel_size == h5d2.pixel_size
@@ -150,10 +147,40 @@ def test_pickling_state_logs():
         data_path / "fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip")
     h5d1 = read.HDF5Data(path)
     h5d1.pixel_size = 0.124
-    state = h5d1.__getstate__()
-    pstate = pickle.dumps(state)
-
-    state2 = pickle.loads(pstate)
-    h5d2 = read.HDF5Data(**state2)
+    pstate = pickle.dumps(h5d1)
+    h5d2 = pickle.loads(pstate)
+    assert h5d1.logs
     for lk in h5d1.logs:
         assert h5d1.logs[lk] == h5d2.logs[lk]
+
+
+def test_pickling_state_tables():
+    path = retrieve_data(
+        data_path / "fmt-hdf5_cytoshot_full-features_legacy_allev_2023.zip")
+    # The original file does not contain any tables, so we write
+    # generate a table
+    columns = ["alot", "of", "tables"]
+    ds_dt = np.dtype({'names': columns,
+                      'formats': [float] * len(columns)})
+    tab_data = np.zeros((11, len(columns)))
+    tab_data[:, 0] = np.arange(11)
+    tab_data[:, 1] = 1000
+    tab_data[:, 2] = np.linspace(1, np.sqrt(2), 11)
+    rec_arr = np.rec.array(tab_data, dtype=ds_dt)
+
+    # add table to source file
+    with h5py.File(path, "a") as h5:
+        h5tab = h5.require_group("tables")
+        h5tab.create_dataset(name="sample_table",
+                             data=rec_arr)
+
+    h5d1 = read.HDF5Data(path)
+    h5d1.pixel_size = 0.124
+    pstate = pickle.dumps(h5d1)
+    h5d2 = pickle.loads(pstate)
+    assert h5d1.tables
+    table = h5d1.tables["sample_table"]
+    assert len(table) == 3
+    for lk in table:
+        assert np.allclose(h5d1.tables["sample_table"][lk],
+                           h5d2.tables["sample_table"][lk])

tests/test_segm_thresh.py

@@ -137,141 +137,3 @@ def test_segm_thresh_segment_batch_large(worker_type):
     for jj in range(101, 121):
         mask_seg = np.array(labels_seg_2[jj - 101], dtype=bool)
         assert np.all(mask_seg == mask[jj]), f"masks not matching at {jj}"
-
-
-def test_segm_thresh_labeled_mask():
-    mask = np.array([
-        [0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 1, 0, 0, 0],
-        [0, 0, 1, 0, 1, 0, 0, 0],  # filled, 1
-        [0, 0, 1, 1, 1, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 1, 1, 1, 1],
-        [0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
-        [0, 0, 0, 0, 0, 1, 1, 1],
-        [0, 1, 1, 1, 0, 0, 0, 0],
-        [0, 0, 1, 1, 1, 0, 0, 0],  # other, 3
-        [0, 0, 1, 1, 1, 0, 0, 0],
-        [0, 0, 1, 1, 1, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0],
-        ], dtype=bool)
-
-    sm1 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": True,
-                                                      "fill_holes": True,
-                                                      "closing_disk": 0,
-                                                      })
-    labels1 = sm1.segment_frame(-10 * mask)
-    assert np.sum(labels1 != 0) == 21
-    assert len(np.unique(labels1)) == 3  # (bg, filled, other)
-    assert np.sum(labels1 == 1) == 9
-    # due to the relabeling done in `fill_holes`, the index of "other" is "3"
-    assert np.sum(labels1 == 2) == 12
-
-    sm2 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": True,
-                                                      "fill_holes": False,
-                                                      "closing_disk": 0,
-                                                      })
-    labels2 = sm2.segment_frame(-10 * mask)
-    _, l2a, l2b = np.unique(labels2)
-    assert np.sum(labels2 != 0) == 20
-    assert len(np.unique(labels2)) == 3  # (bg, filled, other)
-    assert np.sum(labels2 == l2a) == 8
-    assert np.sum(labels2 == l2b) == 12
-
-    sm3 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": False,
-                                                      "fill_holes": False,
-                                                      "closing_disk": 0,
-                                                      })
-    labels3 = sm3.segment_frame(-10 * mask)
-    assert np.sum(labels3 != 0) == 30
-    assert len(np.unique(labels3)) == 4  # (bg, filled, border, other)
-    assert np.sum(labels3 == 1) == 8
-    assert np.sum(labels3 == 2) == 10
-    assert np.sum(labels3 == 3) == 12
-
-    sm4 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": False,
-                                                      "fill_holes": True,
-                                                      "closing_disk": 0,
-                                                      })
-    labels4 = sm4.segment_frame(-10 * mask)
-    assert np.sum(labels4 != 0) == 31
-    assert len(np.unique(labels4)) == 4  # (bg, filled, border, other)
-    assert np.sum(labels4 == 1) == 9
-    assert np.sum(labels4 == 2) == 10
-    assert np.sum(labels4 == 3) == 12
-
-
-def test_segm_thresh_labeled_mask_closing_disk():
-    mask = np.array([
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 1, 1, 1, 0, 0, 0, 0],
-        [0, 0, 1, 0, 1, 0, 0, 0, 0],  # filled, 1
-        [0, 0, 1, 1, 1, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 1, 1, 1, 1],
-        [0, 0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
-        [0, 0, 0, 0, 0, 0, 0, 0, 1],
-        [0, 0, 1, 1, 1, 0, 0, 0, 0],
-        [0, 0, 1, 0, 0, 1, 1, 0, 0],  # other, 3
-        [0, 0, 1, 0, 0, 0, 1, 0, 0],
-        [0, 0, 1, 0, 0, 0, 1, 0, 0],
-        [0, 0, 1, 1, 1, 1, 1, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        [0, 0, 0, 0, 0, 0, 0, 0, 0],
-        ], dtype=bool)
-
-    sm1 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": True,
-                                                      "fill_holes": True,
-                                                      "closing_disk": 1,
-                                                      })
-    labels1 = sm1.segment_frame(-10 * mask)
-    assert np.sum(labels1 != 0) == 32
-    assert len(np.unique(labels1)) == 3  # (bg, filled, other)
-    assert np.sum(labels1 == 1) == 9
-    # due to the relabeling done in `fill_holes`, the index of "other" is "3"
-    assert np.sum(labels1 == 2) == 23
-
-    sm2 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": True,
-                                                      "fill_holes": False,
-                                                      "closing_disk": 1,
-                                                      })
-    labels2 = sm2.segment_frame(-10 * mask)
-    _, l2a, l2b = np.unique(labels2)
-    assert np.sum(labels2 != 0) == 27
-    assert len(np.unique(labels2)) == 3  # (bg, filled, other)
-    assert np.sum(labels2 == l2a) == 9
-    assert np.sum(labels2 == l2b) == 18
-
-    sm3 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": False,
-                                                      "fill_holes": False,
-                                                      "closing_disk": 1,
-                                                      })
-    labels3 = sm3.segment_frame(-10 * mask)
-    assert np.sum(labels3 != 0) == 35
-    assert len(np.unique(labels3)) == 4  # (bg, filled, border, other)
-    assert np.sum(labels3 == 1) == 9
-    assert np.sum(labels3 == 2) == 8
-    assert np.sum(labels3 == 3) == 18
-
-    sm4 = segm.segm_thresh.SegmentThresh(thresh=-6,
-                                         kwargs_mask={"clear_border": False,
-                                                      "fill_holes": True,
-                                                      "closing_disk": 1,
-                                                      })
-    labels4 = sm4.segment_frame(-10 * mask)
-    assert np.sum(labels4 != 0) == 40
-    assert len(np.unique(labels4)) == 4  # (bg, filled, border, other)
-    assert np.sum(labels4 == 1) == 9
-    assert np.sum(labels4 == 2) == 8
-    assert np.sum(labels4 == 3) == 23

tests/test_segmenter.py

@@ -0,0 +1,225 @@
+import pathlib
+
+from dcnum import segm
+import numpy as np
+
+data_path = pathlib.Path(__file__).parent / "data"
+
+
+class MockImageData:
+    mask = np.array([
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0, 0],  # filled, 1
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 1, 1, 1, 1],
+        [0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
+        [0, 0, 0, 0, 0, 1, 1, 1],
+        [0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],  # other, 3
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        ], dtype=bool)
+
+    def get_chunk(self, chunk_index):
+        image = np.array(-(10 + chunk_index) * self.mask, dtype=np.int16)
+        chunk = np.stack([image] * 100, dtype=np.int16)
+        return chunk
+
+
+def test_segmenter_labeled_mask():
+    mask = np.array([
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0, 0],  # filled, 1
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 1, 1, 1, 1],
+        [0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
+        [0, 0, 0, 0, 0, 1, 1, 1],
+        [0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],  # other, 3
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        ], dtype=bool)
+
+    sm1 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": True,
+                                                      "fill_holes": True,
+                                                      "closing_disk": 0,
+                                                      })
+    labels1 = sm1.segment_frame(-10 * mask)
+    assert np.sum(labels1 != 0) == 21
+    assert len(np.unique(labels1)) == 3  # (bg, filled, other)
+    assert np.sum(labels1 == 1) == 9
+    # due to the relabeling done in `fill_holes`, the index of "other" is "3"
+    assert np.sum(labels1 == 2) == 12
+
+    sm2 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": True,
+                                                      "fill_holes": False,
+                                                      "closing_disk": 0,
+                                                      })
+    labels2 = sm2.segment_frame(-10 * mask)
+    _, l2a, l2b = np.unique(labels2)
+    assert np.sum(labels2 != 0) == 20
+    assert len(np.unique(labels2)) == 3  # (bg, filled, other)
+    assert np.sum(labels2 == l2a) == 8
+    assert np.sum(labels2 == l2b) == 12
+
+    sm3 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": False,
+                                                      "fill_holes": False,
+                                                      "closing_disk": 0,
+                                                      })
+    labels3 = sm3.segment_frame(-10 * mask)
+    assert np.sum(labels3 != 0) == 30
+    assert len(np.unique(labels3)) == 4  # (bg, filled, border, other)
+    assert np.sum(labels3 == 1) == 8
+    assert np.sum(labels3 == 2) == 10
+    assert np.sum(labels3 == 3) == 12
+
+    sm4 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": False,
+                                                      "fill_holes": True,
+                                                      "closing_disk": 0,
+                                                      })
+    labels4 = sm4.segment_frame(-10 * mask)
+    assert np.sum(labels4 != 0) == 31
+    assert len(np.unique(labels4)) == 4  # (bg, filled, border, other)
+    assert np.sum(labels4 == 1) == 9
+    assert np.sum(labels4 == 2) == 10
+    assert np.sum(labels4 == 3) == 12
+
+
+def test_segmenter_labeled_mask_closing_disk():
+    mask = np.array([
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0, 0, 0],  # filled, 1
+        [0, 0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 1, 1, 1, 1],
+        [0, 0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
+        [0, 0, 0, 0, 0, 0, 0, 0, 1],
+        [0, 0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 1, 0, 0, 1, 1, 0, 0],  # other, 3
+        [0, 0, 1, 0, 0, 0, 1, 0, 0],
+        [0, 0, 1, 0, 0, 0, 1, 0, 0],
+        [0, 0, 1, 1, 1, 1, 1, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ], dtype=bool)
+
+    sm1 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": True,
+                                                      "fill_holes": True,
+                                                      "closing_disk": 1,
+                                                      })
+    labels1 = sm1.segment_frame(-10 * mask)
+    assert np.sum(labels1 != 0) == 32
+    assert len(np.unique(labels1)) == 3  # (bg, filled, other)
+    assert np.sum(labels1 == 1) == 9
+    # due to the relabeling done in `fill_holes`, the index of "other" is "3"
+    assert np.sum(labels1 == 2) == 23
+
+    sm2 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": True,
+                                                      "fill_holes": False,
+                                                      "closing_disk": 1,
+                                                      })
+    labels2 = sm2.segment_frame(-10 * mask)
+    _, l2a, l2b = np.unique(labels2)
+    assert np.sum(labels2 != 0) == 27
+    assert len(np.unique(labels2)) == 3  # (bg, filled, other)
+    assert np.sum(labels2 == l2a) == 9
+    assert np.sum(labels2 == l2b) == 18
+
+    sm3 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": False,
+                                                      "fill_holes": False,
+                                                      "closing_disk": 1,
+                                                      })
+    labels3 = sm3.segment_frame(-10 * mask)
+    assert np.sum(labels3 != 0) == 35
+    assert len(np.unique(labels3)) == 4  # (bg, filled, border, other)
+    assert np.sum(labels3 == 1) == 9
+    assert np.sum(labels3 == 2) == 8
+    assert np.sum(labels3 == 3) == 18
+
+    sm4 = segm.segm_thresh.SegmentThresh(thresh=-6,
+                                         kwargs_mask={"clear_border": False,
+                                                      "fill_holes": True,
+                                                      "closing_disk": 1,
+                                                      })
+    labels4 = sm4.segment_frame(-10 * mask)
+    assert np.sum(labels4 != 0) == 40
+    assert len(np.unique(labels4)) == 4  # (bg, filled, border, other)
+    assert np.sum(labels4 == 1) == 9
+    assert np.sum(labels4 == 2) == 8
+    assert np.sum(labels4 == 3) == 23
+
+
+def test_segmenter_labeled_mask_fill_holes_int32():
+    mask = np.array([
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 0, 1, 0, 0, 0],  # filled, 1
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 1, 1, 1, 1],
+        [0, 0, 0, 0, 0, 1, 1, 1],  # border, 2
+        [0, 0, 0, 0, 0, 1, 1, 1],
+        [0, 1, 1, 1, 0, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],  # other, 3
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 1, 1, 1, 0, 0, 0],
+        [0, 0, 0, 0, 0, 0, 0, 0],
+        ], dtype=bool)
+
+    sm1 = segm.segm_thresh.SegmentThresh(thresh=-6)
+    labels = np.array(sm1.segment_frame(-10 * mask), dtype=np.int64)
+    # sanity checks
+    assert labels.dtype == np.int64
+    assert labels.dtype != np.int32
+    labels_2 = sm1.process_mask(labels,
+                                clear_border=False,
+                                fill_holes=True,
+                                closing_disk=False)
+    assert np.allclose(labels, labels_2)
+    assert labels_2.dtype == np.int32
+
+
+def test_segmenter_segment_chunk():
+    with segm.segm_thresh.SegmentThresh(thresh=-12, debug=True) as sm:
+        image_data = MockImageData()
+        labels_1 = np.copy(sm.segment_chunk(image_data, 0))  # below threshold
+        assert sm.image_array.min() == -10
+        labels_2 = np.copy(sm.segment_chunk(image_data, 10))  # above threshold
+        assert sm.image_array.min() == -20
+        assert np.all(labels_1 == 0)
+        assert not np.all(labels_2 == 0)
+
+
+def test_cpu_segmenter_getsetstate():
+    sm1 = segm.segm_thresh.SegmentThresh(thresh=-12, debug=True)
+    with segm.segm_thresh.SegmentThresh(thresh=-12, debug=True) as sm2:
+        image_data = MockImageData()
+        # Do some processing so that we have workers
+        sm2.segment_chunk(image_data, 0)
+        # get the state
+        state = sm2.__getstate__()
+        # set the state
+        sm1.__setstate__(state)
+        # and here we test for the raw data that was transferred
+        assert not np.all(sm1.image_array == sm2.image_array)
+        assert np.all(sm1.mp_image_raw == sm2.mp_image_raw)