dcnum 0.13.2__py3-none-any.whl → 0.23.1__py3-none-any.whl

dcnum/write/writer.py

@@ -1,7 +1,8 @@
 import hashlib
 import json
 import pathlib
-from typing import List
+from typing import Dict, List
+import warnings
 
 import h5py
 import hdf5plugin
@@ -10,16 +11,47 @@ import numpy as np
 from .._version import version
 
 
+class CreatingFileWithoutBasinWarning(UserWarning):
+    """Issued when creating a basin-based dataset without basins"""
+    pass
+
+
 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")
-        if ds_kwds is None:
-            ds_kwds = {}
-        for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
-            ds_kwds.setdefault(key, val)
-        ds_kwds.setdefault("fletcher32", True)
+        ds_kwds = set_default_filter_kwargs(ds_kwds)
         self.ds_kwds = ds_kwds
 
     def __enter__(self):
@@ -29,41 +61,43 @@ 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):
-        """Return best chunks for image data
+    def get_best_nd_chunks(item_shape, feat_dtype=np.float64):
+        """Return best chunks for HDF5 datasets
 
         Chunking has performance implications. It’s recommended to keep the
-        total size of your chunks between 10 KiB and 1 MiB. This number defines
-        the maximum chunk size as well as half the maximum cache size for each
-        dataset.
+        total size of dataset chunks between 10 KiB and 1 MiB. This number
+        defines the maximum chunk size as well as half the maximum cache
+        size for each dataset.
         """
-        num_bytes = 1024**2  # between 10KiB and 1 MiB
-        if len(item_shape) == 0:
-            # scalar feature
-            chunk_size_int = 10000
-        else:
-            event_size = np.prod(item_shape) * np.dtype(np.uint8).itemsize
-            chunk_size = num_bytes / event_size
-            chunk_size_int = max(1, int(np.floor(chunk_size)))
+        # 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
+        # compression performance.
+        chunk_size_int = max(10, int(np.floor(chunk_size)))
         return tuple([chunk_size_int] + list(item_shape))
 
-    def require_feature(self, feat, item_shape, dtype, ds_kwds=None):
+    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)),
-                dtype=dtype,
+                dtype=feat_dtype,
                 maxshape=tuple([None] + list(item_shape)),
-                chunks=self.get_best_nd_chunks(item_shape),
+                chunks=self.get_best_nd_chunks(item_shape,
+                                               feat_dtype=feat_dtype),
                 **ds_kwds)
             if len(item_shape) == 2:
                 dset.attrs.create('CLASS', np.string_('IMAGE'))
@@ -81,6 +115,7 @@ class HDF5Writer:
                     paths: List[str | pathlib.Path],
                     features: List[str] = None,
                     description: str | None = None,
+                    mapping: np.ndarray = None
                     ):
         """Write an HDF5-based file basin
 
@@ -94,6 +129,9 @@ class HDF5Writer:
             list of features provided by `paths`
         description: str
             optional string describing the basin
+        mapping: 1D array
+            integer array with indices that map the basin dataset
+            to this dataset
         """
         bdat = {
             "description": description,
@@ -102,8 +140,38 @@ class HDF5Writer:
             "paths": [str(pp) for pp in paths],
             "type": "file",
         }
+        # Explicit features stored in basin file
         if features is not None and len(features):
             bdat["features"] = features
+        # Mapped basin information
+        if mapping is not None:
+            events = self.h5.require_group("events")
+            # Reserve a mapping feature for this dataset
+            for ii in range(10):  # basinmap0 to basinmap9
+                bm_cand = f"basinmap{ii}"
+                if bm_cand in events:
+                    # There is a basin mapping defined in the file. Check
+                    # whether it is identical to ours.
+                    if np.all(events[bm_cand] == mapping):
+                        # Great, we are done here.
+                        feat_basinmap = bm_cand
+                        break
+                    else:
+                        # This mapping belongs to a different basin,
+                        # try the next mapping.
+                        continue
+                else:
+                    # The mapping is not defined in the dataset, and we may
+                    # write it to a new feature.
+                    feat_basinmap = bm_cand
+                    self.store_feature_chunk(feat=feat_basinmap, data=mapping)
+                    break
+            else:
+                raise ValueError(
+                    "You have exhausted the usage of mapped basins for "
+                    "the current dataset. Please revise your analysis "
+                    "pipeline.")
+            bdat["mapping"] = feat_basinmap
         bstring = json.dumps(bdat, indent=2)
         # basin key is its hash
         key = hashlib.md5(bstring.encode("utf-8",
@@ -131,11 +199,38 @@ class HDF5Writer:
             data = 255 * np.array(data, dtype=np.uint8)
         ds, offset = self.require_feature(feat=feat,
                                           item_shape=data.shape[1:],
-                                          dtype=data.dtype)
+                                          feat_dtype=data.dtype)
         dsize = data.shape[0]
         ds.resize(offset + dsize, axis=0)
         ds[offset:offset + dsize] = data
 
+    def store_log(self,
+                  log: str,
+                  data: List[str],
+                  override: bool = False):
+        """Store log data
+
+        Store the log data under the key `log`. The `data`
+        kwarg must be a list of strings. If the log entry
+        already exists, `ValueError` is raised unless
+        `override` is set to True.
+        """
+        logs = self.h5.require_group("logs")
+        if log in logs:
+            if override:
+                del logs[log]
+            else:
+                raise ValueError(
+                    f"Log '{log}' already exists in {self.h5.filename}!")
+        logs.create_dataset(
+            name=log,
+            data=data,
+            shape=(len(data),),
+            # maximum line length
+            dtype=f"S{max([len(ll) for ll in data])}",
+            chunks=True,
+            **self.ds_kwds)
+
 
 def create_with_basins(
         path_out: str | pathlib.Path,
@@ -154,6 +249,10 @@ def create_with_basins(
         commonly used for relative and absolute paths).
     """
     path_out = pathlib.Path(path_out)
+    if not basin_paths:
+        warnings.warn(f"Creating basin-based file '{path_out}' without any "
+                      f"basins, since the list `basin_paths' is empty!",
+                      CreatingFileWithoutBasinWarning)
     with HDF5Writer(path_out, mode="w") as hw:
         # Get the metadata from the first available basin path
 
@@ -184,7 +283,7 @@ def create_with_basins(
             # Copy the metadata from the representative path.
             if prep is not None:
                 # copy metadata
-                with h5py.File(prep) as h5:
+                with h5py.File(prep, libver="latest") as h5:
                     copy_metadata(h5_src=h5, h5_dst=hw.h5)
                     # extract features
                     features = sorted(h5["events"].keys())
@@ -201,43 +300,114 @@ def create_with_basins(
                            )
 
 
+def copy_features(h5_src: h5py.File,
+                  h5_dst: h5py.File,
+                  features: List[str],
+                  mapping: np.ndarray = None,
+                  ):
+    """Copy feature data from one HDF5 file to another
+
+    The feature must not exist in the destination file.
+
+    Parameters
+    ----------
+    h5_src: h5py.File
+        Input HDF5File containing `features` in the "events" group
+    h5_dst: h5py.File
+        Output HDF5File opened in write mode not containing `features`
+    features: List[str]
+        List of features to copy from source to destination
+    mapping: 1D array
+        If given, contains indices in the input file that should be
+        written to the output file. If set to None, all features are written.
+    """
+    ei = h5_src["events"]
+    eo = h5_dst.require_group("events")
+    # This is the size of the output dataset
+    size = h5_dst.attrs["experiment:event count"]
+    hw = HDF5Writer(h5_dst)
+    for feat in features:
+        if feat in eo:
+            raise ValueError(f"Output file {h5_dst.filename} already contains "
+                             f"the feature {feat}.")
+        if not isinstance(ei[feat], h5py.Dataset):
+            raise NotImplementedError(
+                f"Only dataset-based features are supported here, not {feat}")
+        if mapping is None:
+            # Just copy the data as-is.
+            h5py.h5o.copy(src_loc=ei.id,
+                          src_name=feat.encode(),
+                          dst_loc=eo.id,
+                          dst_name=feat.encode(),
+                          )
+        else:
+            # Perform mapping and store the features in chunks to keep
+            # memory usage down.
+            dsi = ei[feat]
+            chunk_size = hw.get_best_nd_chunks(dsi[0].shape, dsi.dtype)[0]
+            start = 0
+            while start < size:
+                chunk_idx = mapping[start:start + chunk_size]
+                # h5py only supports indexing in increasing order
+                chunk_unique, order = np.unique(chunk_idx, return_inverse=True)
+                data_unique = dsi[chunk_unique]
+                data = data_unique[order]
+                hw.store_feature_chunk(feat, data)
+                # increment start
+                start += chunk_size
+
+
 def copy_metadata(h5_src: h5py.File,
-                  h5_dst: h5py.File):
+                  h5_dst: h5py.File,
+                  copy_basins=True):
     """Copy attributes, tables, logs, and basins from one H5File to another
 
     Notes
     -----
     Metadata in `h5_dst` are never overridden, only metadata that
-    are not defined are added.
+    are not defined already are added.
     """
     # compress data
-    ds_kwds = {}
-    for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
-        ds_kwds.setdefault(key, val)
-    ds_kwds.setdefault("fletcher32", True)
+    ds_kwds = set_default_filter_kwargs()
     # set attributes
     src_attrs = dict(h5_src.attrs)
     for kk in src_attrs:
         h5_dst.attrs.setdefault(kk, src_attrs[kk])
+    copy_data = ["logs", "tables"]
+    if copy_basins:
+        copy_data.append("basins")
     # copy other metadata
-    for topic in ["basins", "logs", "tables"]:
+    for topic in copy_data:
         if topic in h5_src:
             for key in h5_src[topic]:
                 h5_dst.require_group(topic)
                 if key not in h5_dst[topic]:
                     data = h5_src[topic][key][:]
-                    if data.dtype == np.dtype("O"):
-                        # convert variable-length strings to fixed-length
-                        max_length = max([len(line) for line in data])
-                        data = np.asarray(data, dtype=f"S{max_length}")
-                    ds = h5_dst[topic].create_dataset(
-                        name=key,
-                        data=data,
-                        **ds_kwds
-                    )
-                    # help with debugging and add some meta-metadata
-                    ds.attrs.update(h5_src[topic][key].attrs)
-                    soft_strings = [ds.attrs.get("software"),
-                                    f"dcnum {version}"]
-                    soft_strings = [s for s in soft_strings if s is not None]
-                    ds.attrs["software"] = " | ".join(soft_strings)
+                    if data.size:  # ignore empty datasets
+                        if data.dtype == np.dtype("O"):
+                            # convert variable-length strings to fixed-length
+                            max_length = max([len(line) for line in data])
+                            data = np.asarray(data, dtype=f"S{max_length}")
+                        ds = h5_dst[topic].create_dataset(
+                            name=key,
+                            data=data,
+                            **ds_kwds
+                        )
+                        # help with debugging and add some meta-metadata
+                        ds.attrs.update(h5_src[topic][key].attrs)
+                        soft_strgs = [ds.attrs.get("software"),
+                                      f"dcnum {version}"]
+                        soft_strgs = [s for s in soft_strgs if s is not None]
+                        ds.attrs["software"] = " | ".join(soft_strgs)
+
+
+def set_default_filter_kwargs(ds_kwds=None, compression=True):
+    if ds_kwds is None:
+        ds_kwds = {}
+    if compression:
+        # compression
+        for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
+            ds_kwds.setdefault(key, val)
+    # checksums
+    ds_kwds.setdefault("fletcher32", True)
+    return ds_kwds

{dcnum-0.13.2.dist-info → dcnum-0.23.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.13.2
+Version: 0.23.1
 Summary: numerics toolbox for imaging deformability cytometry
-Author: Paul Müller
+Author: Maximilian Schlögel, Paul Müller, Raghava Alajangi
 Maintainer-email: Paul Müller <dev@craban.de>
 License: MIT
 Project-URL: source, https://github.com/DC-Analysis/dcnum
@@ -25,6 +25,8 @@ Requires-Dist: numpy >=1.21
 Requires-Dist: opencv-python-headless
 Requires-Dist: scikit-image
 Requires-Dist: scipy >=1.8.0
+Provides-Extra: torch
+Requires-Dist: torch >=2.3 ; extra == 'torch'
 
 |dcnum|
 =======

dcnum-0.23.1.dist-info/RECORD

@@ -0,0 +1,55 @@
+dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
+dcnum/_version.py,sha256=FvSfCBPqaPzqv_nSHIaBJNolXopVkF1cRxifqhCXk4g,413
+dcnum/feat/__init__.py,sha256=jUJYWTD3VIoDNKrmryXbjHb1rGwYtK4b7VPWihYgUoo,325
+dcnum/feat/event_extractor_manager_thread.py,sha256=5HdCQCywyQ5QC56AMjSqCroqif9oOFyiSFWCe07JojM,7820
+dcnum/feat/gate.py,sha256=Yhxq80JoRMmQzBxl35C8NT91c9QcmQa-EIKLuxK6WvE,7221
+dcnum/feat/queue_event_extractor.py,sha256=0ncTQleT1sfc98zYkFuZWxU-akecfTrW6-OOU3z-d8o,15698
+dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
+dcnum/feat/feat_background/base.py,sha256=A-K3qlJ0ABFBGm5eMKYcNCC7ktFAInSm0eR3N3DHQZY,7963
+dcnum/feat/feat_background/bg_copy.py,sha256=PK8x4_Uph-_A6uszZC5uhe1gD1dSRdHnDMEsN0HSGHA,1034
+dcnum/feat/feat_background/bg_roll_median.py,sha256=EyjstMDXFBYuJB1lN6g4Uw7tPm434X3hXQxKSqvcoJ4,13175
+dcnum/feat/feat_background/bg_sparse_median.py,sha256=ab7Boj7cmr6PBdTbyWTj_yNNJSfuowr7u-iSGW989WI,20709
+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=_5H3sXYRN0Uq2eUHn3XUyEHkU_tncEqbqJTC-HZcnGY,5198
+dcnum/logic/__init__.py,sha256=7J3GrwJInNQbrLk61HRIV7X7p69TAIbMYpR34hh6u14,177
+dcnum/logic/ctrl.py,sha256=FyVlizHOIaIGMqINvM-outPywAQU0-5NM7t1dEDml4c,35332
+dcnum/logic/job.py,sha256=H1uDZ1nnNHNWWCe6mS8OWB0Uxc6XUKLISx5xExeplZY,7015
+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=OD79NrZ8waC3julwdH8NjneUuXqSRSHsUDpKzT5pdyU,8432
+dcnum/read/__init__.py,sha256=ksLdV8EkOU3EPje8teCOSehcUeGAZfg9TQ5ltuEUgls,216
+dcnum/read/cache.py,sha256=lisrGG7AyvVitf0h92wh5FvYCsxa0pWyGcAyYwGP-LQ,6471
+dcnum/read/const.py,sha256=GG9iyXDtEldvJYOBnhZjlimzIeBMAt4bSr2-xn2gzzc,464
+dcnum/read/hdf5_data.py,sha256=Yyq02UTILc5ZgIQXpR9Y0wuX2WT8s0g23PraI7KxmJY,23489
+dcnum/read/mapped.py,sha256=UryArlrIsHxjOyimBL2Nooi3r73zuGtnGdqdxa6PK_g,3076
+dcnum/segm/__init__.py,sha256=9cLEAd3JWE8IGqDHV-eSDIYOGBfOepd8OcebtNs8Omk,309
+dcnum/segm/segm_thresh.py,sha256=iVhvIhzO0Gw0t3rXOgH71rOI0CNjJJQq4Gg6BulUhK8,948
+dcnum/segm/segmenter.py,sha256=FWLFDBR-x_85ku2rObA2F-QBrM4IUaUL-YHChLagVvM,14902
+dcnum/segm/segmenter_manager_thread.py,sha256=frM0sMxC7f7TQiFjmpRxuwG2kUBFpW1inV8dtpADHiI,5924
+dcnum/segm/segmenter_mpo.py,sha256=o6mQlITHgEWvQt9v6oCWwAcZUvxE7MOeLE9DFManzpY,13757
+dcnum/segm/segmenter_sto.py,sha256=e6MtN_RWusA0wTExV-FLGpDXNJs1CbSyXcSdWUPBMvM,3959
+dcnum/segm/segm_torch/__init__.py,sha256=re9jVLYvV1GgC7J5vx2LHKeFYVZPpiwubecAV9f_2kA,670
+dcnum/segm/segm_torch/segm_torch_base.py,sha256=G9AhVyD6LkAmk0tkbYnJUSpvcj3_HYf0uqfILZQsyus,4479
+dcnum/segm/segm_torch/segm_torch_mpo.py,sha256=N01dVXai_4eIGfHJrPjg5C2Bkyq1TOeXeJhw3YbGidw,2504
+dcnum/segm/segm_torch/segm_torch_sto.py,sha256=PTOJrP_FkaxZZul8lM4VA2HL3KyxrheDDWWdJbmJdiw,3393
+dcnum/segm/segm_torch/torch_model.py,sha256=5aL6SwSvg1N2gATEGBhP3aA4WTHlvGzQVYuizmh0LrU,3187
+dcnum/segm/segm_torch/torch_postproc.py,sha256=ctirQTmsZnuZGIxkwFWN9arRneHRYJUxaJ_ZyCgjByM,3311
+dcnum/segm/segm_torch/torch_preproc.py,sha256=kjabu76paw23kO7RP7Ik6IY60Kk1VBAHKBAedflA0aQ,4002
+dcnum/write/__init__.py,sha256=QvWHeZmjHI18i-YlGYuzN3i7dVWY9UCReKchrJ-gif0,260
+dcnum/write/deque_writer_thread.py,sha256=ao7F1yrVKyufgC4rC0Y2_Vt7snuT6KpI7W2qVxcjdhk,1994
+dcnum/write/queue_collector_thread.py,sha256=d_WfdsZdFnFsiAY0zVMwUlA4juIMeiWYmE_-rezBQCE,11734
+dcnum/write/writer.py,sha256=e6J8YVqhS7kzkpPIMoDMokJpqSy1WWNdOrwaJof1oVc,15601
+dcnum-0.23.1.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.23.1.dist-info/METADATA,sha256=NL79bLTjTqm5R4HW0TNcVZ9YXqbxH7Xcfl6xuk-hfw4,2280
+dcnum-0.23.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dcnum-0.23.1.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
+dcnum-0.23.1.dist-info/RECORD,,

{dcnum-0.13.2.dist-info → dcnum-0.23.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.3)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dcnum/feat/feat_moments/__init__.py

@@ -1,3 +0,0 @@
-# flake8: noqa: F401
-from .mt_legacy import moments_based_features
-

dcnum/segm/segmenter_gpu.py

@@ -1,45 +0,0 @@
-import abc
-import pathlib
-
-import numpy as np
-import scipy.ndimage as ndi
-
-
-from .segmenter import Segmenter
-
-
-class GPUSegmenter(Segmenter, abc.ABC):
-    mask_postprocessing = False
-
-    def __init__(self, *args, **kwargs):
-        super(GPUSegmenter, self).__init__(*args, **kwargs)
-
-    @staticmethod
-    def _get_model_path(model_file):
-        """Custom hook that may be defined by subclasses"""
-        return pathlib.Path(model_file)
-
-    def segment_batch(self,
-                      image_data: np.ndarray,
-                      start: int = None,
-                      stop: int = None):
-        if stop is None or start is None:
-            start = 0
-            stop = len(image_data)
-
-        image_slice = image_data[start:stop]
-        segm = self.segment_frame_wrapper()
-
-        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-0.13.2.dist-info/RECORD

@@ -1,40 +0,0 @@
-dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=ByxP_AGaDBx1nhN9W4fte2GtMXAPh9eMZ4pSGlztQPc,413
-dcnum/feat/__init__.py,sha256=0oX765AyfL1BcVt-FI6R_i6x5LgYYLeyO5lkxSauI0Y,299
-dcnum/feat/event_extractor_manager_thread.py,sha256=5vcCzAnyg59bpNj-8IV8YM7uHTzqs5du3-KgORNwDok,6020
-dcnum/feat/gate.py,sha256=UEHbj3hkMWNm4tlY8Tz8sOsruhByjJxgO1s-ztQ7WTw,6235
-dcnum/feat/queue_event_extractor.py,sha256=RdA-8OW0uB8svAFRQtUBMp7GBKPisEFvX7mc-RfisqE,13170
-dcnum/feat/feat_background/__init__.py,sha256=mL8QJYK6m3hxTqF6Cuosu__Fm5tZUMa-hTgSGcNw9AE,458
-dcnum/feat/feat_background/base.py,sha256=XcefqydfyOt9vNnIjOOIljdLbN78amTM1oGU65mgg5Y,7367
-dcnum/feat/feat_background/bg_roll_median.py,sha256=E86AiSzpw0RZ0nYL4UdKKkskS5ywKJCLeHlWYfTPS0k,12781
-dcnum/feat/feat_background/bg_sparse_median.py,sha256=COJeY8suHmrHBWiXxTLw3C17-QOnc4R75GMdZiuU3cc,17670
-dcnum/feat/feat_brightness/__init__.py,sha256=j-Gen6zutc74VopPGJsr4eHS-_CRnGnnB73HjKsz1C4,102
-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=RxDTbl-XVVk8HIgihTuqWdmD0ciNGdfg715ShHEGUHs,68
-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=SjYRb917PrFN231M2nVxq12DDH2y72WocsS9yY7xqaI,84
-dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
-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=tHbn7rZWEQYCoMzvt8QXhnBDEY6cRJlKxMlbmMwFhVM,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=3Pti8U7-VZkyNnQR7C53ZV9_ljvn7N-AhCso9_HQkZg,16538
-dcnum/segm/__init__.py,sha256=BNFn7VvWsRmOzxCtvr4AXi3mmWsJSsQlEmGlq7umCac,510
-dcnum/segm/segm_thresh.py,sha256=fim5HRNWq0DUhVRwLf6nmu4gOHAFtydGDRS1Ww_XzFo,1134
-dcnum/segm/segmenter.py,sha256=o5G9JnHG-dHnNwG8IdPK8MideF0IlSDbuYwCdrSr31w,9002
-dcnum/segm/segmenter_cpu.py,sha256=oFiK73swm7UVPZcTLX4cpFHxp1DIyn9AjQ93JB0_Eh4,10072
-dcnum/segm/segmenter_gpu.py,sha256=RKas-IOZqyg99nvjUUD2NuNTd1sYqjzjHEJeunmmjaY,1236
-dcnum/segm/segmenter_manager_thread.py,sha256=xtuk7gnk7xhoRoV_J97rrv7IR3JgeRvVewCDT-chqpk,5172
-dcnum/write/__init__.py,sha256=6vAQECatcd7DJMXFEuab1wdvEiaxisbY8_qmK5tzIwY,207
-dcnum/write/deque_writer_thread.py,sha256=UUn5OYxDvckvhLw3llLYu7y8MI7RfsOhdJhMonKKB3k,1625
-dcnum/write/queue_collector_thread.py,sha256=BivSe5ZA-rTPH4sridXU1yFB6CP7LYzIFudLMbN481s,11793
-dcnum/write/writer.py,sha256=_6aSz6vJYQfgUftwIiIHEtKMAAm83WcaH_OgplqRGzk,8785
-dcnum-0.13.2.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.13.2.dist-info/METADATA,sha256=ItcmJIpJrhbvA1hcXpKS-XWcZFxq2wbnOYDCuPyO5Is,2172
-dcnum-0.13.2.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
-dcnum-0.13.2.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
-dcnum-0.13.2.dist-info/RECORD,,