dcnum 0.17.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

dcnum/segm/segmenter.py

@@ -68,10 +68,8 @@ class Segmenter(abc.ABC):
     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
+        border[[0, -1], :] = True
+        border[:, [0, -1]] = True
         return border
 
     @staticmethod
@@ -121,25 +119,40 @@ class Segmenter(abc.ABC):
         get_ppid: Same method for class instances
         """
         kwargs = copy.deepcopy(kwargs)
-        if kwargs_mask is None and kwargs.get("kwargs_mask", None) is None:
-            raise KeyError("`kwargs_mask` must be either specified as "
-                           "keyword argument to this method or as a key "
-                           "in `kwargs`!")
-        if kwargs_mask is None:
-            # see check above (kwargs_mask may also be {})
-            kwargs_mask = kwargs.pop("kwargs_mask")
-        # Start with the default mask kwargs defined for this subclass
-        kwargs_mask_used = copy.deepcopy(cls.mask_default_kwargs)
-        kwargs_mask_used.update(kwargs_mask)
-        code = cls.get_ppid_code()
-        csegm = kwargs_to_ppid(cls, "segment_approach", kwargs)
-        cmask = kwargs_to_ppid(cls, "process_mask", kwargs_mask_used)
-        return ":".join([code, csegm, cmask])
+        if cls.mask_postprocessing:
+            if kwargs_mask is None and kwargs.get("kwargs_mask", None) is None:
+                raise KeyError("`kwargs_mask` must be either specified as "
+                               "keyword argument to this method or as a key "
+                               "in `kwargs`!")
+            if kwargs_mask is None:
+                # see check above (kwargs_mask may also be {})
+                kwargs_mask = kwargs.pop("kwargs_mask")
+            # Start with the default mask kwargs defined for this subclass
+            kwargs_mask_used = copy.deepcopy(cls.mask_default_kwargs)
+            kwargs_mask_used.update(kwargs_mask)
+        elif kwargs_mask:
+            raise ValueError(f"The segmenter '{cls.__name__}' does not "
+                             f"support mask postprocessing, but 'kwargs_mask' "
+                             f"was provided: {kwargs_mask}")
+
+        ppid_parts = [
+            cls.get_ppid_code(),
+            kwargs_to_ppid(cls, "segment_approach", kwargs),
+            ]
+
+        if cls.mask_postprocessing:
+            ppid_parts.append(
+                kwargs_to_ppid(cls, "process_mask", kwargs_mask_used))
+
+        return ":".join(ppid_parts)
 
     @staticmethod
     def get_ppkw_from_ppid(segm_ppid):
         """Return keyword arguments for this pipeline identifier"""
-        code, pp_kwargs, pp_kwargs_mask = segm_ppid.split(":")
+        ppid_parts = segm_ppid.split(":")
+        code = ppid_parts[0]
+        pp_kwargs = ppid_parts[1]
+
         for cls_code in get_available_segmenters():
             if cls_code == code:
                 cls = get_available_segmenters()[cls_code]
@@ -150,9 +163,11 @@ class Segmenter(abc.ABC):
         kwargs = ppid_to_kwargs(cls=cls,
                                 method="segment_approach",
                                 ppid=pp_kwargs)
-        kwargs["kwargs_mask"] = ppid_to_kwargs(cls=cls,
-                                               method="process_mask",
-                                               ppid=pp_kwargs_mask)
+        if cls.mask_postprocessing:
+            pp_kwargs_mask = ppid_parts[2]
+            kwargs["kwargs_mask"] = ppid_to_kwargs(cls=cls,
+                                                   method="process_mask",
+                                                   ppid=pp_kwargs_mask)
         return kwargs
 
     @staticmethod
@@ -196,25 +211,6 @@ class Segmenter(abc.ABC):
                         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
-
-        if closing_disk:
-            #
-            # from skimage import morphology
-            # morphology.binary_closing(
-            #    mask,
-            #    footprint=morphology.disk(closing_disk),
-            #    out=mask)
-            #
-            element = Segmenter.get_disk(closing_disk)
-            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(
-                input=labels_eroded > 0,
-                structure=ndi.generate_binary_structure(2, 2))
-
         if fill_holes:
             # Floodfill only works with uint8 (too small) or int32
             if labels.dtype != np.int32:
@@ -226,17 +222,52 @@ class Segmenter(abc.ABC):
             # Floodfill algorithm fills the background image and
             # the resulting inversion is the image with holes filled.
             # This will destroy labels (adding 2,147,483,647 to background)
+            # Since floodfill will use the upper left corner of the image as
+            # a seed, we have to make sure it is set to background. We set
+            # a line of pixels in the upper channel wall to zero to be sure.
+            labels[0, :] = 0
+            # ...and a 4x4 pixel region in the top left corner.
+            labels[1, :2] = 0
             cv2.floodFill(labels, None, (0, 0), 2147483647)
             mask = labels != 2147483647
             labels, _ = ndi.label(
                 input=mask,
                 structure=ndi.generate_binary_structure(2, 2))
 
+        if closing_disk:
+            # scikit-image is too slow for us here. So we use OpenCV.
+            # https://github.com/scikit-image/scikit-image/issues/1190
+            #
+            # from skimage import morphology
+            # morphology.binary_closing(
+            #    mask,
+            #    footprint=morphology.disk(closing_disk),
+            #    out=mask)
+            #
+            element = Segmenter.get_disk(closing_disk)
+            # Note: erode/dilate not implemented for int32
+            labels_uint8 = np.array(labels, dtype=np.uint8)
+            # Historically, we would like to do a closing (dilation followed
+            # by erosion) on the image data where lower brightness values
+            # meant "we have an event". However, since we are now working
+            # with labels instead of image data (0 is background and labels
+            # are enumerated with integers), high "brightness" values are
+            # actually the event. Thus, we have to perform an opening
+            # (erosion followed by dilation) of the label image.
+            labels_eroded = cv2.erode(labels_uint8, element)
+            labels_dilated = cv2.dilate(labels_eroded, element)
+            labels, _ = ndi.label(
+                input=labels_dilated > 0,
+                structure=ndi.generate_binary_structure(2, 2))
+
         return labels
 
-    def segment_chunk(self, image_data, chunk):
+    def segment_chunk(self, image_data, chunk, bg_off=None):
         """Return the integer labels for one `image_data` chunk"""
         data = image_data.get_chunk(chunk)
+        if bg_off is not None:
+            bg_off_chunk = bg_off[image_data.get_chunk_slice(chunk)]
+            data = data - bg_off_chunk.reshape(-1, 1, 1)
         return self.segment_batch(data)
 
     def segment_frame(self, image):

dcnum/segm/segmenter_cpu.py

@@ -96,11 +96,11 @@ class CPUSegmenter(Segmenter, abc.ABC):
         batch_size: int
             Number of images in the array
         dtype:
-            ctype, e.g. `np.ctypeslib.ctypes.c_uint8`
-            or `np.ctypeslib.ctypes.c_bool`
+            numpy dtype
         """
         sx, sy = image_shape
-        sa_raw = mp_spawn.RawArray(dtype, int(sx * sy * batch_size))
+        ctype = np.ctypeslib.as_ctypes_type(dtype)
+        sa_raw = mp_spawn.RawArray(ctype, int(sx * sy * batch_size))
         # Convert the RawArray to something we can write to fast
         # (similar to memory view, but without having to cast) using
         # np.ctypeslib.as_array. See discussion in
@@ -172,14 +172,14 @@ class CPUSegmenter(Segmenter, abc.ABC):
             self.mp_image_raw, self._mp_image_np = self._create_shared_array(
                 image_shape=self.image_shape,
                 batch_size=batch_size,
-                dtype=np.ctypeslib.ctypes.c_int32,
+                dtype=image_data.dtype,
             )
 
         if self._mp_labels_np is None:
             self.mp_labels_raw, self._mp_labels_np = self._create_shared_array(
                 image_shape=self.image_shape,
                 batch_size=batch_size,
-                dtype=np.ctypeslib.ctypes.c_uint16,
+                dtype=np.uint16,
             )
 
         # populate image data

dcnum/segm/segmenter_manager_thread.py

@@ -17,6 +17,7 @@ class SegmenterManagerThread(threading.Thread):
                  image_data: HDF5ImageCache | ImageCorrCache,
                  slot_states: mp.Array,
                  slot_chunks: mp.Array,
+                 bg_off: np.ndarray = None,
                  debug: bool = False,
                  *args, **kwargs):
         """Manage the segmentation of image data
@@ -38,6 +39,10 @@ class SegmenterManagerThread(threading.Thread):
         slot_chunks:
             For each slot in `slot_states`, this shared array defines
             on which chunk in `image_data` the segmentation took place.
+        bg_off:
+            1d array containing additional background image offset values
+            that are added to each background image before subtraction
+            from the input image
         debug:
             Whether to run in debugging mode (more verbose messages and
             CPU-based segmentation is done in one single thread instead
@@ -65,6 +70,8 @@ class SegmenterManagerThread(threading.Thread):
         self.segmenter = segmenter
         #: Image data which is being segmented
         self.image_data = image_data
+        #: Additional, optional background offset
+        self.bg_off = bg_off
         #: Slot states
         self.slot_states = slot_states
         #: Current slot chunk index for the slot states
@@ -89,7 +96,7 @@ class SegmenterManagerThread(threading.Thread):
                 # - "s" the extractor processed the data and is waiting
                 #   for the segmenter
                 if self.slot_states[cur_slot] != "e":
-                    # It's the segmenters turn. Note that we use '!= "e"',
+                    # It's the segmenter's turn. Note that we use '!= "e"',
                     # because the initial value is "\x00".
                     break
                 else:
@@ -106,7 +113,9 @@ class SegmenterManagerThread(threading.Thread):
             # We have a free slot to compute the segmentation
             labels = self.segmenter.segment_chunk(
                 image_data=self.image_data,
-                chunk=chunk)
+                chunk=chunk,
+                bg_off=self.bg_off,
+            )
 
             # TODO: make this more memory efficient (pre-shared mp.Arrays?)
             # Store labels in a list accessible by the main thread

dcnum/write/writer.py

@@ -1,7 +1,7 @@
 import hashlib
 import json
 import pathlib
-from typing import List
+from typing import Dict, List
 import warnings
 
 import h5py
@@ -17,9 +17,39 @@ class CreatingFileWithoutBasinWarning(UserWarning):
 
 
 class HDF5Writer:
-    def __init__(self, path, mode="a", ds_kwds=None):
-        """Write deformability cytometry HDF5 data"""
-        self.h5 = h5py.File(path, mode=mode, libver="latest")
+    def __init__(self,
+                 # TODO: make this a mandatory argument when `path` is
+                 #       properly removed
+                 obj: h5py.File | pathlib.Path | str = None,
+                 mode: str = "a",
+                 ds_kwds: Dict = None,
+                 path: pathlib.Path | str = None,
+                 ):
+        """Write deformability cytometry HDF5 data
+
+        Parameters
+        ----------
+        obj: h5py.File | pathlib.Path | str
+            object to instantiate the writer from; If this is already
+            a :class:`h5py.File` object, then it is used, otherwise the
+            argument is passed to :class:`h5py.File`
+        mode: str
+            opening mode when using :class:`h5py.File`
+        ds_kwds: Dict
+            keyword arguments with which to initialize new Datasets
+            (e.g. compression)
+        """
+        if path is not None:
+            obj = path
+            warnings.warn("The `path` keyword argument is deprecated, use "
+                          "`obj` instead",
+                          DeprecationWarning)
+        if isinstance(obj, h5py.File):
+            self.h5 = obj
+            self.h5_owned = False
+        else:
+            self.h5 = h5py.File(obj, mode=mode, libver="latest")
+            self.h5_owned = True
         self.events = self.h5.require_group("events")
         ds_kwds = set_default_filter_kwargs(ds_kwds)
         self.ds_kwds = ds_kwds
@@ -31,7 +61,9 @@ class HDF5Writer:
         self.close()
 
     def close(self):
-        self.h5.close()
+        self.h5.flush()
+        if self.h5_owned:
+            self.h5.close()
 
     @staticmethod
     def get_best_nd_chunks(item_shape, feat_dtype=np.float64):

{dcnum-0.17.2.dist-info → dcnum-0.18.0.dist-info}/METADATA

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

dcnum-0.18.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
+dcnum/_version.py,sha256=qQfZIFMnYUfFvdZIkQ7KTINCu5N5FVIhIaHGQZyIg1E,413
+dcnum/feat/__init__.py,sha256=jUJYWTD3VIoDNKrmryXbjHb1rGwYtK4b7VPWihYgUoo,325
+dcnum/feat/event_extractor_manager_thread.py,sha256=Ocid_t1awH6pOmurCmKYkC51XsXB0-DoN3fzjFDgE4c,7129
+dcnum/feat/gate.py,sha256=svbObmqpYdqPawpfrsEjTiUPJXf24GrNi8PXTKT-z44,7225
+dcnum/feat/queue_event_extractor.py,sha256=XhA930QVQ1Z4saisbcGTrEut-fSgwTyfDn6b9GzD4iY,15644
+dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
+dcnum/feat/feat_background/base.py,sha256=IYBFfsGXBfmFnZfD9QrmfrXbJtFSfVOS-v-u-uxSThs,7985
+dcnum/feat/feat_background/bg_copy.py,sha256=muU-6eTUf3HTA2K2asrLWcR_hbRMjdygZROmjNXCm7Q,923
+dcnum/feat/feat_background/bg_roll_median.py,sha256=G1atu6R8FWDe-Lblr1KcdP368Xx-kj6oy3q2mhljxB0,13064
+dcnum/feat/feat_background/bg_sparse_median.py,sha256=-CShs4UAuZd00rACaXTZj3dccKevhcSGRsILFgMPLWo,20705
+dcnum/feat/feat_brightness/__init__.py,sha256=o6AebVlmydwNgVF5kW6ITqJyFreoKrU3Ki_3EC8If-s,155
+dcnum/feat/feat_brightness/bright_all.py,sha256=vf8xaYBdKD24hHUXdkI0_S7nbr7m49KW6gvuWvbHDVg,4545
+dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
+dcnum/feat/feat_contour/__init__.py,sha256=Td4Hs47kUgJj0VXm3q5ofXhaUWr9QTfVgbwh5EELA-I,163
+dcnum/feat/feat_contour/contour.py,sha256=_qyHCGvylVxruMWafvVbVOzhWGXLoFi10LReNxGcWhY,463
+dcnum/feat/feat_contour/moments.py,sha256=W8sD2X7JqIBq-9nL82hf4Hm2uJkfca8EvAl_hqI_IDg,5109
+dcnum/feat/feat_contour/volume.py,sha256=xVHWtv6USUHJZ5dM1Ur7fI7OwoPT5N2Ps0gKVWylfl8,6639
+dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9CjuTgH0,137
+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=dZlQBUhFrBOs5jkdtFX60g_1M_3A05kXqmCkWTTfyHk,27998
+dcnum/logic/job.py,sha256=M0Q-Rfcm-zkTXTQc79W6YSNUjUlgmRPG0Ikbdn1aOpY,4608
+dcnum/logic/json_encoder.py,sha256=cxMnqisbKEVf-rVcw6rK2BBAb6iz_hKFaGl81kK36lQ,571
+dcnum/meta/__init__.py,sha256=AVqRgyKXO1orKnE305h88IBvoZ1oz6X11HN1WP5nGvg,60
+dcnum/meta/paths.py,sha256=J_ikeHzd7gEeRgAKjuayz3x6q4h1fOiDadM-ZxhAGm4,1053
+dcnum/meta/ppid.py,sha256=Q3jg8lZt5tlGIby_-7rBqTANesMjJrmxASXZhsvBD_Y,7706
+dcnum/read/__init__.py,sha256=8uGj4YN7pDP4FO9TkZWXrpScwTLVWSEZexFq-TS9vsA,215
+dcnum/read/cache.py,sha256=kC2Y9hXA92ARQ2Vgm1kBFCU-s6TPE1tPYvpzWI0aPow,5619
+dcnum/read/const.py,sha256=8ih8rlWM7ntp8phrr9dh22hXXb210igSCatOSI9Ou30,463
+dcnum/read/hdf5_data.py,sha256=sGqwaj3HpceSsctlVFty-3TRnWeN09WNfUh30xkt5b0,20598
+dcnum/read/mapped.py,sha256=X__uqz5rT-N_xJhr6QsmsvXzIqu806piuTyjTHd_Ewg,2777
+dcnum/segm/__init__.py,sha256=iiq_1A9DU5wMUcKnsZ53E7NyzCkbZCJeUDimzunE-OM,247
+dcnum/segm/segm_thresh.py,sha256=lMf-lso_O_5Q5lJiiIQdYkM3zlj4uwNz9cNvLxVMeXc,1396
+dcnum/segm/segmenter.py,sha256=gVzmP6CuwI9Qfk8GN_xWGu_xbtVTOhxIOWn-2yr_H1Y,12220
+dcnum/segm/segmenter_cpu.py,sha256=IzhPNQaO4TBh3EzZqLGaBAeRryfBKnld7Joe8qY4AB4,10690
+dcnum/segm/segmenter_gpu.py,sha256=Au1MQdAalVsmJ-cmb3OcCmEMBfXSDuJjdXJTGqEIcG8,1962
+dcnum/segm/segmenter_manager_thread.py,sha256=xQEioOkASlm8DTdG0RBtjCJP1cOuiyJAm4q2n1l_tfM,5710
+dcnum/write/__init__.py,sha256=Cpn3LqL18hh8OScUnGp_AnNfpWPpKW-oAJZH6ot7aRA,241
+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=nlJfQCPoW2Wze72y_256G4qmgYMdh5mL0vpvqg7lSaU,11728
+dcnum-0.18.0.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.18.0.dist-info/METADATA,sha256=Vnx_UzKsj2G9X16joXk6QOZWmDmvVmBgwXiuiGvK65o,2194
+dcnum-0.18.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dcnum-0.18.0.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
+dcnum-0.18.0.dist-info/RECORD,,

dcnum/feat/feat_moments/__init__.py

@@ -1,4 +0,0 @@
-# flake8: noqa: F401
-"""Feature computation: OpenCV moments-based features"""
-from .mt_legacy import moments_based_features
-

dcnum-0.17.2.dist-info/RECORD

@@ -1,46 +0,0 @@
-dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=9PqbWPkwwMgdNmE4GP1v5LyzvjNYATMHB-uIEy0c_aI,413
-dcnum/feat/__init__.py,sha256=JqlgzOgDJhoTk8WVYcIiKTWq9EAM16_jGivzOtN6JGo,325
-dcnum/feat/event_extractor_manager_thread.py,sha256=Ocid_t1awH6pOmurCmKYkC51XsXB0-DoN3fzjFDgE4c,7129
-dcnum/feat/gate.py,sha256=svbObmqpYdqPawpfrsEjTiUPJXf24GrNi8PXTKT-z44,7225
-dcnum/feat/queue_event_extractor.py,sha256=3CIjZOwOD8JZZTgbE9_jC81B8lbNtVElSV371Q9zoSc,15005
-dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
-dcnum/feat/feat_background/base.py,sha256=DKcNSQOSi0cuo4zFbqtgDJnRiYDwoKkw2GQxpnK14fA,8119
-dcnum/feat/feat_background/bg_copy.py,sha256=EbeIy28gyPJr01Xens881IC1BtaTS5q-BkXPd3b6cLk,726
-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
-dcnum/feat/feat_moments/__init__.py,sha256=9eKmhBZGAZTLRnfCNHDiYM0a7qErrJCFLEgy3OlF9no,125
-dcnum/feat/feat_moments/ct_opencv.py,sha256=_qyHCGvylVxruMWafvVbVOzhWGXLoFi10LReNxGcWhY,463
-dcnum/feat/feat_moments/mt_legacy.py,sha256=tp85oeQ1GwVNdo6nXWhtbUGjMaXR8C6NMMWhobzThq0,4490
-dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9CjuTgH0,137
-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=7m1HL_kO62d8Kt_o4gX3bhxbI4pwOhv3HWHRmbCaMp0,27022
-dcnum/logic/job.py,sha256=M0Q-Rfcm-zkTXTQc79W6YSNUjUlgmRPG0Ikbdn1aOpY,4608
-dcnum/logic/json_encoder.py,sha256=dy44ArmdnxpUfxxONmKdIv-fde3aTXPjZDN0HPATaxs,467
-dcnum/meta/__init__.py,sha256=AVqRgyKXO1orKnE305h88IBvoZ1oz6X11HN1WP5nGvg,60
-dcnum/meta/paths.py,sha256=J_ikeHzd7gEeRgAKjuayz3x6q4h1fOiDadM-ZxhAGm4,1053
-dcnum/meta/ppid.py,sha256=f3xT6k9EMhrmk2T_e-2LHE9qdXeGMZJcNOIIpr-_eb4,7706
-dcnum/read/__init__.py,sha256=iV2wrBMdwJgpXaphNiiAVybndDzTTv0CAGRNXyvxcLY,157
-dcnum/read/cache.py,sha256=HXbRFyTNT08_imv2460hMKVrfRrU6WnbJoO71HR1j8E,5800
-dcnum/read/const.py,sha256=ccME3dOK7DEXNhkTD90I7KF8zagzZufnbFkrYwQeIUo,307
-dcnum/read/hdf5_data.py,sha256=Tn-DXmtroJbrzBZK7x73MD-nEEyv0D08_OHgwcdC8IQ,18202
-dcnum/segm/__init__.py,sha256=iiq_1A9DU5wMUcKnsZ53E7NyzCkbZCJeUDimzunE-OM,247
-dcnum/segm/segm_thresh.py,sha256=Z6buG3ia8uFJKTLE6BICM3n7Yw8IN-9f6_umIlx0xUk,1395
-dcnum/segm/segmenter.py,sha256=Y535ro4BTyE5Uj5lYIZ0xMbpKg2TIs5wCpv1Gg-yvTU,10625
-dcnum/segm/segmenter_cpu.py,sha256=tCY105rVr9_0RIq2618qnF1ueHRj7UtuK_nUBoAg-nY,10743
-dcnum/segm/segmenter_gpu.py,sha256=Au1MQdAalVsmJ-cmb3OcCmEMBfXSDuJjdXJTGqEIcG8,1962
-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=KpJ6po8JPlM696MITN-bhNnWQcy9E-qlhg9g-uzoPZg,1710
-dcnum/write/queue_collector_thread.py,sha256=YQ6pvKNmCDf1C6HVx6gOA-q-FBoI6nkhOo-tAVYnyag,11906
-dcnum/write/writer.py,sha256=QGYNda102f2_12YWXu5WEBEQaTXhNnuQ20g-Dej-cek,10535
-dcnum-0.17.2.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.17.2.dist-info/METADATA,sha256=oS5cJxipnS9ugEpkDfRmV2WosWj_W2lFf-2w8XkOe5o,2194
-dcnum-0.17.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dcnum-0.17.2.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
-dcnum-0.17.2.dist-info/RECORD,,