dcnum 0.16.5__py3-none-any.whl → 0.16.7__py3-none-any.whl

dcnum/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.16.5'
-__version_tuple__ = version_tuple = (0, 16, 5)
+__version__ = version = '0.16.7'
+__version_tuple__ = version_tuple = (0, 16, 7)

dcnum/feat/event_extractor_manager_thread.py

@@ -1,4 +1,5 @@
 """Feature computation: managing event extraction threads"""
+import collections
 import logging
 import multiprocessing as mp
 import threading
@@ -17,6 +18,7 @@ class EventExtractorManagerThread(threading.Thread):
                  labels_list: List,
                  fe_kwargs: Dict,
                  num_workers: int,
+                 writer_dq: collections.deque,
                  debug: bool = False,
                  *args, **kwargs):
         """Manage event extraction threads or precesses
@@ -40,6 +42,9 @@ class EventExtractorManagerThread(threading.Thread):
             :func:`.EventExtractor.get_init_kwargs` for more information.
         num_workers:
             Number of child threads or worker processes to use.
+        writer_dq:
+            The queue the writer uses. We monitor this queue. If it
+            fills up, we take a break.
         debug:
             Whether to run in debugging mode which means more log
             messages and only one thread (`num_workers` has no effect).
@@ -66,6 +71,8 @@ class EventExtractorManagerThread(threading.Thread):
         self.label_array = np.ctypeslib.as_array(
             self.fe_kwargs["label_array"]).reshape(
             self.data.image.chunk_shape)
+        #: Writer deque to monitor
+        self.writer_dq = writer_dq
         #: Time counter for feature extraction
         self.t_count = 0
         #: Whether debugging is enabled
@@ -86,6 +93,15 @@ class EventExtractorManagerThread(threading.Thread):
         chunks_processed = 0
         frames_processed = 0
         while True:
+            # If the writer_dq starts filling up, then this could lead to
+            # an oom-kill signal. Stall for the writer to prevent this.
+            ldq = len(self.writer_dq)
+            if ldq > 100:
+                stallsec = ldq / 100
+                self.logger.warning(
+                    f"Stalling {stallsec:.1f}s for slow writer.")
+                time.sleep(stallsec)
+
             cur_slot = 0
             unavailable_slots = 0
             # Check all slots for segmented labels

dcnum/feat/feat_background/bg_roll_median.py

@@ -95,12 +95,12 @@ class BackgroundRollMed(Background):
         #: queue for median computation jobs
         self.queue = mp_spawn.Queue()
         #: list of workers (processes)
-        self.workers = [MedianWorker(self.queue,
-                                     self.worker_counter,
-                                     self.shared_input_raw,
-                                     self.shared_output_raw,
-                                     self.batch_size,
-                                     self.kernel_size)
+        self.workers = [WorkerRollMed(self.queue,
+                                      self.worker_counter,
+                                      self.shared_input_raw,
+                                      self.shared_output_raw,
+                                      self.batch_size,
+                                      self.kernel_size)
                         for _ in range(self.num_cpus)]
         [w.start() for w in self.workers]
 
@@ -216,11 +216,11 @@ class BackgroundRollMed(Background):
         self.image_proc.value += self.batch_size
 
 
-class MedianWorker(mp_spawn.Process):
+class WorkerRollMed(mp_spawn.Process):
     def __init__(self, job_queue, counter, shared_input, shared_output,
                  batch_size, kernel_size, *args, **kwargs):
         """Worker process for median computation"""
-        super(MedianWorker, self).__init__(*args, **kwargs)
+        super(WorkerRollMed, self).__init__(*args, **kwargs)
         self.queue = job_queue
         self.queue.cancel_join_thread()
         self.counter = counter

dcnum/feat/feat_background/bg_sparse_median.py

@@ -152,11 +152,11 @@ class BackgroundSparseMed(Background):
         #: queue for median computation jobs
         self.queue = mp_spawn.Queue()
         #: list of workers (processes)
-        self.workers = [MedianWorkerSingle(self.queue,
-                                           self.worker_counter,
-                                           self.shared_input_raw,
-                                           self.shared_output_raw,
-                                           self.kernel_size)
+        self.workers = [WorkerSparseMed(self.queue,
+                                        self.worker_counter,
+                                        self.shared_input_raw,
+                                        self.shared_output_raw,
+                                        self.kernel_size)
                         for _ in range(self.num_cpus)]
         [w.start() for w in self.workers]
 
@@ -348,11 +348,11 @@ class BackgroundSparseMed(Background):
         self.image_proc.value = idx_stop
 
 
-class MedianWorkerSingle(mp_spawn.Process):
+class WorkerSparseMed(mp_spawn.Process):
     def __init__(self, job_queue, counter, shared_input, shared_output,
                  kernel_size, *args, **kwargs):
         """Worker process for median computation"""
-        super(MedianWorkerSingle, self).__init__(*args, **kwargs)
+        super(WorkerSparseMed, self).__init__(*args, **kwargs)
         self.queue = job_queue
         self.queue.cancel_join_thread()
         self.counter = counter

dcnum/feat/gate.py

@@ -1,5 +1,6 @@
-"""Feature computation: gating after feature extraction"""
+"""Feature gating"""
 import copy
+import numbers
 import warnings
 
 import numpy as np
@@ -11,7 +12,8 @@ class Gate:
     #: the default value for `size_thresh_mask` if not given as kwarg
     _default_size_thresh_mask = 10
 
-    def __init__(self, data, *, online_gates: bool = False,
+    def __init__(self, data, *,
+                 online_gates: bool = False,
                  size_thresh_mask: int = None):
         """Gate feature data
 
@@ -20,51 +22,43 @@ class Gate:
         data: .HDF5Data
             dcevent data instance
         online_gates: bool
-            set to True to enable gating with `online_filters`
+            set to True to enable gating with "online" gates stored
+            in the input file; online gates are applied in real-time
+            deformability cytometry before writing data to disk during
+            a measurement
         size_thresh_mask: int
             Only masks with more pixels than `size_thresh_mask` are
-            considered to be a valid event; Originally, this
-            `trig_thresh` value defaulted to 200, but this seemed to
-            be a little too large, defaults to 10.
+            considered to be a valid event; Originally, the
+            `bin area min`/`trig_thresh` value defaulted to 200 which is
+            too large; defaults to 10 or the original value in case
+            `online_gates` is set.
         """
-        #: dcevent .HDF5Data instance
-        self.data = data
-
-        #: gating keyword arguments
-        self.kwargs = {}
+        #: box gating (value range for each feature)
+        self.box_gates = {}
 
         if online_gates:
-            self.box_gates = self._compute_online_gates()
-            # Set triggering threshold to value from source dataset
-            self._set_kwarg("size_thresh_mask", "online_contour",
-                            "bin area min", size_thresh_mask)
-            # If the user did not provide a value and there is nothing in the
-            # original file, then set the default value.
-            if self.kwargs.get("size_thresh_mask") is None:
-                self.kwargs["size_thresh_mask"] = \
-                    self._default_size_thresh_mask
-        else:
-            self.box_gates = {}
-            # If the user did not provide a size_thresh_mask, use the default.
+            # Deal with online gates.
+            # First, compute the box gates.
+            self.box_gates.update(self._extract_online_gates(data))
+            # If the user did not specify a threshold, attempt to extract
+            # it from the metadata.
             if size_thresh_mask is None:
-                size_thresh_mask = self._default_size_thresh_mask
-            self.kwargs["size_thresh_mask"] = size_thresh_mask
-
-        self.kwargs["online_gates"] = online_gates
-
-    def _set_kwarg(self, name, sec, key, user_value):
-        if user_value is None:
-            value = self.data.meta_nest.get(sec, {}).get(key)
-        else:
-            value = user_value
-        if value is not None:
-            self.kwargs[name] = value
+                size_thresh_mask = data.meta_nest.get(
+                    "online_contour", {}).get("bin area min")
 
-    def _compute_online_gates(self):
-        all_online_filters = {}
+        #: gating keyword arguments
+        self.kwargs = {
+            "online_gates": online_gates,
+            # Set the size threshold, defaulting to `_default_size_thresh_mask`
+            "size_thresh_mask":
+                size_thresh_mask or self._default_size_thresh_mask
+        }
+
+    def _extract_online_gates(self, data):
+        ogates = {}
         # Extract online filters from the dataset
-        of = self.data.meta_nest.get("online_filter", {})
-        for key in of:
+        source_meta = data.meta_nest.get("online_filter", {})
+        for key in source_meta:
             if key.endswith("polygon points"):
                 raise NotImplementedError("Polygon gating not implemented!")
             elif (key.endswith("soft limit")
@@ -72,66 +66,30 @@ class Gate:
                 # we only want hard gates
                 continue
             else:
-                # only add the filter if it is not a soft limit
-                sl = of.get(f"{key.rsplit(' ', 1)[0]} soft limit", True)
-                if not sl:
-                    all_online_filters[key] = of[key]
+                try:
+                    feat, lim = key.rsplit(' ', 1)
+                    lim_idx = ["min", "max"].index(lim)
+                except ValueError:
+                    warnings.warn(f"Unexpected online gate '{key}'")
+                else:
+                    # make sure we are not dealing with a soft limit
+                    if not source_meta.get(f"{feat} soft limit", True):
+                        ogates.setdefault(feat, [None, None])
+                        ogates[feat][lim_idx] = source_meta[key]
 
         # This is somehow hard-coded in Shape-In (minimum size is 3px)
-        px_size = self.data.pixel_size
-        all_online_filters["size_x min"] = max(
-            all_online_filters.get("size_x min", 0), 3 * px_size)
-        all_online_filters["size_y min"] = max(
-            all_online_filters.get("size_y min", 0), 3 * px_size)
-
-        return all_online_filters
-
-    def gate_feature(self, feat, data):
-        valid_left = True
-        valid_right = True
-        if f"{feat} min" in self.box_gates:
-            valid_left = data > self.box_gates[f"{feat} min"]
-        if f"{feat} max" in self.box_gates:
-            valid_right = data < self.box_gates[f"{feat} max"]
-        return np.logical_and(valid_left, valid_right)
+        px_size = data.pixel_size
+        ogates["size_x"] = [
+            max(ogates.get("size_x min", 0), 3 * px_size), None]
+        ogates["size_y"] = [
+            max(ogates.get("size_y min", 0), 3 * px_size), None]
 
-    def gate_event(self, event):
-        """Return None if the event should not be used, else `event`"""
-        if self.box_gates and event:
-            # Only use those events that are within the limits of the
-            # online filters.
-            for feat in self.features:
-                if not self.gate_feature(feat, event[feat]):
-                    return
-        return event
+        return ogates
 
-    def gate_events(self, events):
-        """Return boolean array with events that should be used"""
-        if self.box_gates and bool(events):
-            key0 = list(events.keys())[0]
-            size = len(events[key0])
-            valid = np.ones(size, dtype=bool)
-            for feat in self.features:
-                valid = np.logical_and(valid,
-                                       self.gate_feature(feat, events[feat])
-                                       )
-        else:
-            raise ValueError("Empty events provided!")
-        return valid
-
-    def gate_mask(self, mask, mask_sum=None):
-        """Gate the mask, return False if the mask should not be used
-
-        Parameters
-        ----------
-        mask: 2d ndarray
-            The boolean mask image for the event.
-        mask_sum: int
-            The sum of the mask (if not specified, it is computed)
-        """
-        if mask_sum is None:
-            mask_sum = np.sum(mask)
-        return mask_sum > self.kwargs["size_thresh_mask"]
+    @property
+    def features(self):
+        """Sorted list of feature gates defined"""
+        return sorted(self.box_gates.keys())
 
     def get_ppid(self):
         """Return a unique gating pipeline identifier
@@ -181,13 +139,63 @@ class Gate:
                                 ppid=pp_gate_kwargs)
         return kwargs
 
-    @property
-    def features(self):
-        return [kk.split()[0] for kk in list(self.box_gates.keys())]
-
     @classmethod
     def get_ppid_from_kwargs(cls, kwargs):
         warnings.warn(
             "Please use get_ppid_from_ppkw instead of get_ppid_from_kwargs",
             DeprecationWarning)
         return cls.get_ppid_from_ppkw(kwargs)
+
+    def gate_event(self, event):
+        """Return None if the event should not be used, else `event`"""
+        if self.box_gates and event:
+            # Only use those events that are within the limits of the
+            # online filters.
+            for feat in self.features:
+                if not self.gate_feature(feat, event[feat]):
+                    return
+        return event
+
+    def gate_events(self, events):
+        """Return boolean array with events that should be used"""
+        if self.box_gates and bool(events):
+            key0 = list(events.keys())[0]
+            size = len(events[key0])
+            valid = np.ones(size, dtype=bool)
+            for feat in self.features:
+                valid = np.logical_and(valid,
+                                       self.gate_feature(feat, events[feat])
+                                       )
+        else:
+            raise ValueError("Empty events provided!")
+        return valid
+
+    def gate_feature(self,
+                     feat: str,
+                     data: numbers.Number | np.ndarray):
+        """Return boolean indicating whether `data` value is in box gate
+
+        `data` may be a number or an array. If no box filter is defined
+        for `feat`, `True` is always returned. Otherwise, either a boolean
+        or a boolean array is returned, depending on the type of `data`.
+        Not that `np.logical_and` can deal with mixed argument types
+        (scalar and array).
+        """
+        bound_lo, bound_up = self.box_gates[feat]
+        valid_lo = data >= bound_lo if bound_lo is not None else True
+        valid_up = data <= bound_up if bound_up is not None else True
+        return np.logical_and(valid_lo, valid_up)
+
+    def gate_mask(self, mask, mask_sum=None):
+        """Gate the mask, return False if the mask should not be used
+
+        Parameters
+        ----------
+        mask: 2d ndarray
+            The boolean mask image for the event.
+        mask_sum: int
+            The sum of the mask (if not specified, it is computed)
+        """
+        if mask_sum is None:
+            mask_sum = np.sum(mask)
+        return mask_sum > self.kwargs["size_thresh_mask"]

dcnum/logic/ctrl.py

@@ -546,6 +546,7 @@ class DCNumJobRunner(threading.Thread):
             fe_kwargs=fe_kwargs,
             num_workers=num_extractors,
             labels_list=thr_segm.labels_list,
+            writer_dq=writer_dq,
             debug=self.job["debug"])
         thr_feat.start()
 

dcnum/read/hdf5_data.py

@@ -386,8 +386,8 @@ def concatenated_hdf5_data(paths: List[pathlib.Path],
     path_out:
         If `None`, then the dataset is created in memory. If `True`
         (default), create a file on disk. If a pathlib.Path is specified,
-        the dataset is written to that file. Note that files in memory
-        are liekely not pickable (so don't use for multiprocessing).
+        the dataset is written to that file. Note that datasets in memory
+        are likely not pickable (so don't use them for multiprocessing).
     compute_frame:
         Whether to compute the "events/frame" feature, taking the frame
         data from the input files and properly incrementing them along
@@ -435,7 +435,8 @@ def concatenated_hdf5_data(paths: List[pathlib.Path],
                 # get metadata
                 if ii == 0:
                     meta = dict(h5.attrs)
-                    features = featsi
+                    if not features:
+                        features = featsi
                 # make sure number of features are consistent
                 if not set(features) <= set(featsi):
                     raise ValueError(

dcnum/segm/segmenter.py

@@ -64,6 +64,17 @@ class Segmenter(abc.ABC):
                 "`kwargs_mask` has been specified, but mask post-processing "
                 f"is disabled for segmenter {self.__class__}")
 
+    @staticmethod
+    @functools.cache
+    def get_border(shape):
+        """Cached boolean image with outer pixels set to True"""
+        border = np.zeros(shape, dtype=bool)
+        border[0, :] = True
+        border[-1, :] = True
+        border[:, 0] = True
+        border[:, -1] = True
+        return border
+
     @staticmethod
     @functools.cache
     def get_disk(radius):
@@ -178,14 +189,13 @@ class Segmenter(abc.ABC):
             #
             if (labels[0, :].sum() or labels[-1, :].sum()
                     or labels[:, 0].sum() or labels[:, -1].sum()):
-                border = np.zeros_like(labels, dtype=bool)
-                border[0] = True
-                border[-1] = True
-                border[:, 0] = True
-                border[:, -1] = True
+                border = Segmenter.get_border(labels.shape)
                 indices = sorted(np.unique(labels[border]))
-                for ii in indices[1:]:
-                    labels[labels == ii] = 0
+                for li in indices:
+                    if li == 0:
+                        # ignore background values
+                        continue
+                    labels[labels == li] = 0
 
         # scikit-image is too slow for us here. So we use OpenCV.
         # https://github.com/scikit-image/scikit-image/issues/1190

dcnum/write/deque_writer_thread.py

@@ -41,11 +41,13 @@ class DequeWriterThread(threading.Thread):
 
     def run(self):
         while True:
+            ldq = len(self.dq)
             if self.must_stop_loop:
                 break
-            elif len(self.dq):
-                feat, data = self.dq.popleft()
-                self.writer.store_feature_chunk(feat=feat, data=data)
+            elif ldq:
+                for _ in range(ldq):
+                    feat, data = self.dq.popleft()
+                    self.writer.store_feature_chunk(feat=feat, data=data)
             elif self.may_stop_loop:
                 break
             else:

dcnum/write/writer.py

@@ -35,7 +35,7 @@ class HDF5Writer:
 
     @staticmethod
     def get_best_nd_chunks(item_shape, feat_dtype=np.float64):
-        """Return best chunks for image data
+        """Return best chunks for HDF5 datasets
 
         Chunking has performance implications. It’s recommended to keep the
         total size of dataset chunks between 10 KiB and 1 MiB. This number
@@ -44,6 +44,7 @@ class HDF5Writer:
         """
         # set image feature chunk size to approximately 1MiB
         num_bytes = 1024 ** 2
+        # Note that `np.prod(()) == 1`
         event_size = np.prod(item_shape) * np.dtype(feat_dtype).itemsize
         chunk_size = num_bytes / event_size
         # Set minimum chunk size to 10 so that we can have at least some
@@ -53,12 +54,11 @@ class HDF5Writer:
 
     def require_feature(self, feat, item_shape, feat_dtype, ds_kwds=None):
         """Create a new feature in the "events" group"""
-
-        if ds_kwds is None:
-            ds_kwds = {}
-        for key in self.ds_kwds:
-            ds_kwds.setdefault(key, self.ds_kwds[key])
         if feat not in self.events:
+            if ds_kwds is None:
+                ds_kwds = {}
+            for key in self.ds_kwds:
+                ds_kwds.setdefault(key, self.ds_kwds[key])
             dset = self.events.create_dataset(
                 feat,
                 shape=tuple([0] + list(item_shape)),

{dcnum-0.16.5.dist-info → dcnum-0.16.7.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.16.5
+Version: 0.16.7
 Summary: numerics toolbox for imaging deformability cytometry
-Author: Paul Müller
+Author: Maximilian Schlögel, Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>
 License: MIT
 Project-URL: source, https://github.com/DC-Analysis/dcnum

{dcnum-0.16.5.dist-info → dcnum-0.16.7.dist-info}/RECORD

@@ -1,14 +1,14 @@
 dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=A9EjHk6VWE1N9f9I9BmZdBVFE4e3iVwMNZvbEgWWRIs,413
+dcnum/_version.py,sha256=qnrnqIwaxxSmbCyOa5NQksqjVQLJBzYOk8VUPMYeuoY,413
 dcnum/feat/__init__.py,sha256=JqlgzOgDJhoTk8WVYcIiKTWq9EAM16_jGivzOtN6JGo,325
-dcnum/feat/event_extractor_manager_thread.py,sha256=re0McYaWv6h-unLj2B0OhfQtWs-prqIazC8vbDUDQ30,6480
-dcnum/feat/gate.py,sha256=4wMss9hm4xmJVxScYQM8ScvJs0nlSyTpirRiJFkMsUk,7059
+dcnum/feat/event_extractor_manager_thread.py,sha256=NSoey-h-STIAvadHWDbkhXsB6FZ_SkYnBbEC6JWkTQ0,7130
+dcnum/feat/gate.py,sha256=ZTV2tkNqJBGmwemZrI0IAaPXTLgWO_5ZVxnpqr2G1cI,7464
 dcnum/feat/queue_event_extractor.py,sha256=eacmcM_uHHW6GtqCCtDCZib9423TGvuqgxGKAxv0tgc,15686
 dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
 dcnum/feat/feat_background/base.py,sha256=IPHJN9Stdk7WZbbAn5VPNLMZmA2VTL_I0IdJNEgPFNw,8374
 dcnum/feat/feat_background/bg_copy.py,sha256=EbeIy28gyPJr01Xens881IC1BtaTS5q-BkXPd3b6cLk,726
-dcnum/feat/feat_background/bg_roll_median.py,sha256=FfC3v1cX8mreLO971C_kTpFRBtuJP4Sv-Hj1Wj8yb3Q,12826
-dcnum/feat/feat_background/bg_sparse_median.py,sha256=KW7hWwUuwF5fJaJmdWK8L-uG83ngrS3DepPSxSkZQG4,17629
+dcnum/feat/feat_background/bg_roll_median.py,sha256=HgiGoyfLkygIlCoo8cBbf3gQt5uvM2S6_ez_V1hhCb4,12834
+dcnum/feat/feat_background/bg_sparse_median.py,sha256=LbWbDxAruGagidHt9wybyqkXp9OKi3eWXceujirpsqY,17608
 dcnum/feat/feat_brightness/__init__.py,sha256=o6AebVlmydwNgVF5kW6ITqJyFreoKrU3Ki_3EC8If-s,155
 dcnum/feat/feat_brightness/bright_all.py,sha256=Z5b-xkw7g7ejMpbGmdUqrxGRymqFhAQsZ938gaGXk9Y,3102
 dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
@@ -19,7 +19,7 @@ dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9C
 dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
 dcnum/feat/feat_texture/tex_all.py,sha256=eGjjNfPpfZw7FA_VNFCIMiU38KD0qcGbxLciYy-tCiA,4097
 dcnum/logic/__init__.py,sha256=7J3GrwJInNQbrLk61HRIV7X7p69TAIbMYpR34hh6u14,177
-dcnum/logic/ctrl.py,sha256=a_qroJPyr-UV2M8EZTnYKP4kGnMETvFjBgVyShhVkuw,26692
+dcnum/logic/ctrl.py,sha256=Gd17hdEYTxvdXZkTqqul4WUCu5wf4Gf0f8LZJ9EX83k,26725
 dcnum/logic/job.py,sha256=M0Q-Rfcm-zkTXTQc79W6YSNUjUlgmRPG0Ikbdn1aOpY,4608
 dcnum/logic/json_encoder.py,sha256=dy44ArmdnxpUfxxONmKdIv-fde3aTXPjZDN0HPATaxs,467
 dcnum/meta/__init__.py,sha256=cQT_HN5yDKzMnZM8CUyNmeA68OhE3ENO_rvFmgDj95c,40
@@ -27,19 +27,19 @@ dcnum/meta/ppid.py,sha256=_xUqJal4wBqgic2aRN3ZMMteTggHeYGs44nrYbTKlpQ,8107
 dcnum/read/__init__.py,sha256=iV2wrBMdwJgpXaphNiiAVybndDzTTv0CAGRNXyvxcLY,157
 dcnum/read/cache.py,sha256=HXbRFyTNT08_imv2460hMKVrfRrU6WnbJoO71HR1j8E,5800
 dcnum/read/const.py,sha256=SVlvEJiRIHyTyUlWG24_ogcnT5nTxCi0CRslNuNP56I,282
-dcnum/read/hdf5_data.py,sha256=R9z6OjhsfwaJ6zzkEqi_JF1jRJJLEXwObTkclLBQ2rc,18816
+dcnum/read/hdf5_data.py,sha256=tRSfBmrAZo7yNAnFLMj9yfh26_23pHxkZclX6RyzcYg,18864
 dcnum/segm/__init__.py,sha256=iiq_1A9DU5wMUcKnsZ53E7NyzCkbZCJeUDimzunE-OM,247
 dcnum/segm/segm_thresh.py,sha256=aLVTydPjbrgKDkZFY3Ew5CX-miwOw71meHfxcO5EjCc,1176
-dcnum/segm/segmenter.py,sha256=F3gCp-Z51F9GxdFYPF1CHjnbfgqnS0_g-34lJF2tMCM,10611
+dcnum/segm/segmenter.py,sha256=g0sDBawObeMu4nhZ9rT8lqErsYYu3KApIKGW96aFvr8,10897
 dcnum/segm/segmenter_cpu.py,sha256=tCY105rVr9_0RIq2618qnF1ueHRj7UtuK_nUBoAg-nY,10743
 dcnum/segm/segmenter_gpu.py,sha256=tL2X5BN0jKmhC7wgfG0hygd-6UpG1ZCVuKe5OP1qde0,2133
 dcnum/segm/segmenter_manager_thread.py,sha256=2znDaKedSueomcU1pbHtFmVcGoHzp--sf494VgJF_Tk,5342
 dcnum/write/__init__.py,sha256=Cpn3LqL18hh8OScUnGp_AnNfpWPpKW-oAJZH6ot7aRA,241
-dcnum/write/deque_writer_thread.py,sha256=R4x3p-HZUls3upCBX3vV1VqSdSmaiHdrAswMJj_tVpk,1643
+dcnum/write/deque_writer_thread.py,sha256=KpJ6po8JPlM696MITN-bhNnWQcy9E-qlhg9g-uzoPZg,1710
 dcnum/write/queue_collector_thread.py,sha256=YQ6pvKNmCDf1C6HVx6gOA-q-FBoI6nkhOo-tAVYnyag,11906
-dcnum/write/writer.py,sha256=Hr37OSDJGUpJJ4OufJHYYBanE26GiNwUPOMAt-5Yc2Y,10478
-dcnum-0.16.5.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.16.5.dist-info/METADATA,sha256=dp0FeVQE2ii3AujU8v8FOPi4XLqvJkB3vGhgJcOnR44,2172
-dcnum-0.16.5.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-dcnum-0.16.5.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
-dcnum-0.16.5.dist-info/RECORD,,
+dcnum/write/writer.py,sha256=QGYNda102f2_12YWXu5WEBEQaTXhNnuQ20g-Dej-cek,10535
+dcnum-0.16.7.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.16.7.dist-info/METADATA,sha256=-FkRf9AUrKMuhTWwUp4SQnkYOKZ4KK4s6inH0Q2rZ4Q,2194
+dcnum-0.16.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+dcnum-0.16.7.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
+dcnum-0.16.7.dist-info/RECORD,,