particle-pack-tools 0.0.7__tar.gz

particle_pack_tools-0.0.7/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

particle_pack_tools-0.0.7/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: particle-pack-tools
+Version: 0.0.7
+Summary: A toolkit for processing and visualizing particle pack data.
+Author-email: Bogong Wang <bogongwang.dev@outlook.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/bogongwang/particle-pack-tools
+Project-URL: Repository, https://github.com/bogongwang/particle-pack-tools
+Keywords: particle pack,tools,visualization,data processing,particle pack
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray>=2025.1
+Requires-Dist: dask>=2025.1
+Requires-Dist: netCDF4>=1.7.2
+Requires-Dist: scikit-image>=0.25.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: numpy>=1.25.0
+Requires-Dist: numba>=0.60.0
+Requires-Dist: matplotlib>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# Particle Pack Tools
+
+## Installation
+To install the package, run:
+```
+pip install particle-pack-tools
+```
+
+## Usage
+
+### Dataset I/O
+Load particle pack datasets using:
+```
+from pptools.io import load_nc, load_nc_arr
+```
+
+### Dataset Preprocessing
+Preprocess particle pack datasets with:
+```
+from pptools.preprocess import crop_3d
+# ...additional preprocessing functions...
+```
+
+### Dataset Visualization
+Visualize particle pack datasets using the `Visualizer` class:
+```
+from pptools.visualize import Visualizer
+
+# Initialize the visualizer
+vis = Visualizer()
+
+# Plot a tomogram
+vis.plot_tomo(tomo_img)
+vis.show()
+
+# Plot a multi-label mask
+vis.plot_mask(mask_img)
+vis.show()
+```
+
+---
+
+Feel free to report any issues or share suggestions to help improve this toolkit.

particle_pack_tools-0.0.7/README.md

@@ -0,0 +1,43 @@
+# Particle Pack Tools
+
+## Installation
+To install the package, run:
+```
+pip install particle-pack-tools
+```
+
+## Usage
+
+### Dataset I/O
+Load particle pack datasets using:
+```
+from pptools.io import load_nc, load_nc_arr
+```
+
+### Dataset Preprocessing
+Preprocess particle pack datasets with:
+```
+from pptools.preprocess import crop_3d
+# ...additional preprocessing functions...
+```
+
+### Dataset Visualization
+Visualize particle pack datasets using the `Visualizer` class:
+```
+from pptools.visualize import Visualizer
+
+# Initialize the visualizer
+vis = Visualizer()
+
+# Plot a tomogram
+vis.plot_tomo(tomo_img)
+vis.show()
+
+# Plot a multi-label mask
+vis.plot_mask(mask_img)
+vis.show()
+```
+
+---
+
+Feel free to report any issues or share suggestions to help improve this toolkit.

particle_pack_tools-0.0.7/particle_pack_tools.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: particle-pack-tools
+Version: 0.0.7
+Summary: A toolkit for processing and visualizing particle pack data.
+Author-email: Bogong Wang <bogongwang.dev@outlook.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/bogongwang/particle-pack-tools
+Project-URL: Repository, https://github.com/bogongwang/particle-pack-tools
+Keywords: particle pack,tools,visualization,data processing,particle pack
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xarray>=2025.1
+Requires-Dist: dask>=2025.1
+Requires-Dist: netCDF4>=1.7.2
+Requires-Dist: scikit-image>=0.25.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: numpy>=1.25.0
+Requires-Dist: numba>=0.60.0
+Requires-Dist: matplotlib>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# Particle Pack Tools
+
+## Installation
+To install the package, run:
+```
+pip install particle-pack-tools
+```
+
+## Usage
+
+### Dataset I/O
+Load particle pack datasets using:
+```
+from pptools.io import load_nc, load_nc_arr
+```
+
+### Dataset Preprocessing
+Preprocess particle pack datasets with:
+```
+from pptools.preprocess import crop_3d
+# ...additional preprocessing functions...
+```
+
+### Dataset Visualization
+Visualize particle pack datasets using the `Visualizer` class:
+```
+from pptools.visualize import Visualizer
+
+# Initialize the visualizer
+vis = Visualizer()
+
+# Plot a tomogram
+vis.plot_tomo(tomo_img)
+vis.show()
+
+# Plot a multi-label mask
+vis.plot_mask(mask_img)
+vis.show()
+```
+
+---
+
+Feel free to report any issues or share suggestions to help improve this toolkit.

particle_pack_tools-0.0.7/particle_pack_tools.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+particle_pack_tools.egg-info/PKG-INFO
+particle_pack_tools.egg-info/SOURCES.txt
+particle_pack_tools.egg-info/dependency_links.txt
+particle_pack_tools.egg-info/requires.txt
+particle_pack_tools.egg-info/top_level.txt
+pptools/__init__.py
+pptools/io.py
+pptools/preprocess.py
+pptools/visualize.py

particle_pack_tools-0.0.7/particle_pack_tools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

particle_pack_tools-0.0.7/particle_pack_tools.egg-info/requires.txt

@@ -0,0 +1,14 @@
+xarray>=2025.1
+dask>=2025.1
+netCDF4>=1.7.2
+scikit-image>=0.25.0
+scipy>=1.15.0
+numpy>=1.25.0
+numba>=0.60.0
+matplotlib>=3.10.0
+
+[dev]
+pytest>=7.0
+
+[test]
+pytest>=7.0

particle_pack_tools-0.0.7/particle_pack_tools.egg-info/top_level.txt

@@ -0,0 +1 @@
+pptools

particle_pack_tools-0.0.7/pptools/__init__.py

@@ -0,0 +1,7 @@
+"""
+Package for processing and visualizing particle pack data.
+"""
+__all__ = ["io", "preprocess", "visualize"]
+__version__ = "0.0.1"
+__author__ = "Bogong Wang"
+__email__ = "bogongwang.dev@outlook.com"

particle_pack_tools-0.0.7/pptools/io.py

@@ -0,0 +1,480 @@
+import os
+from typing import Tuple, Optional
+import warnings
+
+import numpy as np
+import xarray as xr
+import dask.array as da
+from netCDF4 import Dataset
+
+def load_nc(path: str, varname: Optional[str] = None) -> xr.Dataset:
+    """
+    Load netCDF files into an xarray Dataset, attempting to interpret data based on a priority list 
+    or a specific variable name.
+
+    Args:
+        path: Path to a netCDF file or list of paths. Wildcards supported.
+        varname: Specific variable to load. If None, attempts to load ["tomo", "labels", "distance_map", "segmented"] in order.
+                 The concat_dim is derived as f"{varname}_zdim".
+
+    Returns:
+        xarray.Dataset: The loaded dataset.
+    """
+    LOAD_ORDER = ["tomo", "labels", "distance_map", "segmented"]
+    candidates = [varname] if varname else LOAD_ORDER
+    errors = {}
+
+    for var in candidates:
+        try:
+            return xr.open_mfdataset(
+                path,
+                concat_dim=f"{var}_zdim",
+                data_vars="minimal",
+                combine="nested",
+                combine_attrs="drop_conflicts",
+                coords="minimal",
+                compat="override",
+            )
+        except Exception as e:
+            errors[f'varname={var}'] = str(e)
+
+    raise RuntimeError(f"Failed to load netCDF. Tried: {candidates}. Errors: {errors}. Try specifying 'varname' explicitly.")
+
+def load_nc_arr(path: str, varname: Optional[str] = None) -> da.Array:
+    """
+    Load netCDF files and return the specific data array as a Dask array.
+
+    Args:
+        path: Path to a netCDF file or list of paths.
+        varname: Specific variable to load. If None, follows standard priority order.
+
+    Returns:
+        dask.array.Array: The raw data array of the loaded variable.
+    """
+    LOAD_ORDER = ["tomo", "labels", "distance_map", "segmented"]
+    candidates = [varname] if varname else LOAD_ORDER
+    ds = load_nc(path, varname)
+    
+    # If auto-detected, find which variable from the priority list exists in the dataset.
+    for var in candidates:
+        if var in ds:
+            return ds[var].data
+            
+    raise RuntimeError(f"Dataset loaded, but could not locate any of {candidates} in variables: {list(ds.data_vars)}")
+
+class NCWriter:
+    """
+    NCWriter is a utility class for creating, writing to, and managing NetCDF files.
+
+    This class provides methods to:
+      - Create a new NetCDF file with specified label dimensions and attributes.
+      - Open an existing NetCDF label file for modification.
+      - Write 2D slices into a 3D label dataset efficiently.
+      - Support context manager protocol for safe usage with 'with' statements.
+      - Finalize and close the NetCDF file, ensuring data integrity.
+
+    Usage:
+        with NCWriter("output_labels.nc") as nw:
+            nw.create_labels_nc(shape=(10, 128, 128), attrs={"description": "Segmentation labels"})
+            for z in range(10):
+                nw.write(z, label_slice[z])
+        # File is automatically closed at the end of the with block.
+
+    Key Features:
+        - Efficient partial writing of large label volumes.
+        - Optional attribute storage.
+        - Automatic resource management via context manager.
+    """
+    def __init__(
+        self,
+        path: str,
+    ):
+        """
+        Initialize a NCWriter instance for a given NetCDF file path.
+
+        Args:
+            path (str): Path to the NetCDF file to create or open. If the file exists, it is opened for writing; otherwise, a new file can be created with `create_labels_nc`.
+        """
+        self.path = path
+        self._dataset= None
+        self._nc_arr = None
+        self._shape = None
+        self._varname = None
+    
+    def __enter__(self):
+        """
+        Enter the context manager, returning this NCWriter instance.
+        Enables use with 'with' statements for automatic cleanup.
+        """
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        """
+        Exit the context manager, automatically closing the NetCDF file and releasing resources.
+        """
+        self.close()
+    
+    def open(self, varname="labels"):
+        """
+        Open an existing NetCDF file for writing.
+
+        Args:
+            varname (str, optional): Name of the variable to write to (default: 'labels').
+
+        Behaviour:
+            Opens the specified NetCDF file in read/write mode and initializes internal arrays.
+        """
+        self._varname = varname
+        self._open_nc()
+
+    def create_nc(
+        self,
+        shape: Tuple[int, int, int],
+        varname: str = "labels",
+        attrs: dict = None,
+        complevel: int = 2,
+        overwrite: bool = False,
+    ):
+        """
+        Create a new NetCDF file with specified shape and attributes.
+
+        Args:
+            shape (tuple): A tuple of (z, y, x) specifying the dimensions of the label volume.
+            attrs (dict, optional): Attributes to store in the NetCDF file's global attributes.
+            complevel (int, optional): Compression level for zlib compression (default: 2).
+            overwrite (bool, optional): If True, overwrite an existing file at the path; otherwise, raises an error if file exists.
+
+        Behaviour:
+            Creates a NetCDF file with dimensions ('labels_zdim', 'labels_ydim', 'labels_xdim') and a variable 'labels'.
+            Applies optional compression and stores provided attributes.
+            Opens the file for subsequent writing.
+        """
+        if self._dataset:
+            if overwrite:
+                self.close()
+                os.remove(self.path)
+                print(f"Existing nc file at {self.path} was overwritten.")
+            else:
+                raise FileExistsError(f"File {self.path} already exists (overwrite is disabled).")
+        self._varname = varname
+        dimensions = (f'{self._varname}_zdim', f'{self._varname}_ydim', f'{self._varname}_xdim')
+        ds = Dataset(self.path, 'w')
+        ds.createDimension(dimensions[0], shape[0])
+        ds.createDimension(dimensions[1], shape[1])
+        ds.createDimension(dimensions[2], shape[2])
+        ds.createVariable(
+            varname=self._varname, 
+            datatype=np.int32,
+            dimensions=dimensions,
+            zlib=True,
+            complevel=complevel,
+            shuffle=False,
+            chunksizes=(1, shape[1], shape[2]),
+            fill_value=-1
+        )
+        if attrs:
+            for key, val in attrs.items():
+                setattr(ds, key, val)
+        ds.close()
+        self._open_nc()
+
+    def write(self, idx: int, data: np.ndarray, sync: bool = True):
+        """
+        Write a 2D data slice into the 3D label dataset at the specified index.
+
+        Args:
+            idx (int): Index along the z-dimension where the data slice will be written.
+            data (np.ndarray): 2D numpy array of shape (y, x) to write into the dataset.
+            sync (bool, optional): If True (default), flush changes to disk immediately. Always flushes on the last slice.
+
+        Behaviour:
+            Overwrites the specified z-slice in the NetCDF variable 'labels' with the provided data.
+        """
+        assert data.shape == self._shape[1:], f"Data shape {data.shape} does not match expected shape {self._shape[1:]}"
+        self._nc_arr[idx] = data
+        # Flush on request or on last slice
+        if sync or (idx == self._shape[0] - 1):
+            self.sync()
+    
+    def write_block(
+        self, 
+        data: np.ndarray, 
+        offset: Tuple[int] = (0, 0, 0), 
+        sync: bool = True
+    ):
+        """
+        Write a 3D data block into the label dataset starting at the specified index.
+
+        Args:
+            data (np.ndarray): 3D numpy array of shape (z, y, x) to write into the dataset.
+            offset (tuple): A tuple of (z_start, y_start, x_start) specifying where to write the data block.
+            sync (bool, optional): If True (default), flush changes to disk immediately after writing.
+
+        Behaviour:
+            Overwrites a sub-volume in the NetCDF variable 'labels' with the provided data block.
+        """
+        z_start, y_start, x_start = offset
+        z_end = z_start + data.shape[0]
+        y_end = y_start + data.shape[1]
+        x_end = x_start + data.shape[2]
+        data_mask = data > 0
+        if np.any(data_mask):
+            write_target = self._nc_arr[z_start:z_end, y_start:y_end, x_start:x_end]
+            # netCDF4 returns a copy for slices, so mutate then assign back explicitly
+            write_target[data_mask] = data[data_mask]
+            self._nc_arr[z_start:z_end, y_start:y_end, x_start:x_end] = write_target
+        if sync:
+            self.sync()
+    
+    def replace(self, idx: int, src: int, dst: int):
+        """
+        Replace all occurrences of a label value within a 2D slice of the dataset.
+
+        Args:
+            idx (int): Index along the z-dimension specifying which slice to modify.
+            src (int): Source label value to be replaced.
+            dst (int): Destination label value to replace the source with.
+
+        Behaviour:
+            Scans the specified z-slice in the NetCDF variable 'labels' and replaces
+            all pixels with value `src` by `dst`. The modification is performed in-place.
+        """
+        self._nc_arr[idx] = xr.where(self._nc_arr[idx] == src, dst, self._nc_arr[idx])
+    
+    def sync(self):
+        """
+        Flush any pending changes in the dataset to disk.
+
+        Behaviour:
+            Ensures that all modifications made to the NetCDF variable 'labels'
+            are written to disk, keeping the on-disk data consistent with memory.
+            Useful after multiple write or correct operations.
+        """
+        self._dataset.sync()
+
+    def close(self):
+        """
+        Finalize and close the NetCDF label file.
+
+        Ensures all data is flushed to disk and resources are released. Safe to call multiple times.
+        """
+        if self._dataset:
+            self._dataset.sync()
+            self._dataset.close()
+            self._dataset = None
+            self._nc_arr = None
+
+    def _open_nc(self):
+        """
+        Open an existing NetCDF file in read/write mode and initialize internal arrays.
+
+        This method is called automatically when opening an existing file or after creating a new one,
+        setting up the internal dataset and reference to the 'labels' variable for writing.
+        """
+        if not self._dataset:
+            self._dataset = Dataset(self.path, 'r+')
+            self._nc_arr = self._dataset[self._varname]
+            self._shape = self._nc_arr.shape
+
+class MaskWriter:
+    """
+    MaskWriter is a utility class for creating, writing to, and managing NetCDF label (mask) files.
+
+    This class provides methods to:
+      - Create a new NetCDF file with specified label dimensions and attributes.
+      - Open an existing NetCDF label file for modification.
+      - Write 2D slices into a 3D label dataset efficiently.
+      - Support context manager protocol for safe usage with 'with' statements.
+      - Finalize and close the NetCDF file, ensuring data integrity.
+
+    Usage:
+        with MaskWriter("output_labels.nc") as mw:
+            mw.create_labels_nc(shape=(10, 128, 128), attrs={"description": "Segmentation labels"})
+            for z in range(10):
+                mw.write(z, label_slice[z])
+        # File is automatically closed at the end of the with block.
+
+    Key Features:
+        - Efficient partial writing of large label volumes.
+        - Optional attribute storage.
+        - Automatic resource management via context manager.
+    """
+    def __init__(
+        self,
+        path: str,
+    ):
+        """
+        Initialize a MaskWriter instance for a given NetCDF file path.
+
+        Args:
+            path (str): Path to the NetCDF file to create or open. If the file exists, it is opened for writing; otherwise, a new file can be created with `create_labels_nc`.
+        """
+        warnings.warn(
+            "MaskWriter is deprecated and will be removed by 0.0.10 versions. Please use NCWriter instead.", 
+            DeprecationWarning
+        )
+        self.path = path
+        self._dataset= None
+        self._labels_arr = None
+        self._shape = None
+        if os.path.exists(path):
+            self._open_labels_nc()
+    
+    def __enter__(self):
+        """
+        Enter the context manager, returning this MaskWriter instance.
+        Enables use with 'with' statements for automatic cleanup.
+        """
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        """
+        Exit the context manager, automatically closing the NetCDF file and releasing resources.
+        """
+        self.close()
+
+    def create_labels_nc(
+        self,
+        shape: Tuple[int, int, int],
+        attrs: dict = None,
+        complevel: int = 2,
+        overwrite: bool = False,
+    ):
+        """
+        Create a new NetCDF file for labels with specified shape and attributes.
+
+        Args:
+            shape (tuple): A tuple of (z, y, x) specifying the dimensions of the label volume.
+            attrs (dict, optional): Attributes to store in the NetCDF file's global attributes.
+            complevel (int, optional): Compression level for zlib compression (default: 2).
+            overwrite (bool, optional): If True, overwrite an existing file at the path; otherwise, raises an error if file exists.
+
+        Behaviour:
+            Creates a NetCDF file with dimensions ('labels_zdim', 'labels_ydim', 'labels_xdim') and a variable 'labels'.
+            Applies optional compression and stores provided attributes.
+            Opens the file for subsequent writing.
+        """
+        if self._dataset:
+            if overwrite:
+                self.close()
+                os.remove(self.path)
+                print(f"Existing nc file at {self.path} was overwritten.")
+            else:
+                raise FileExistsError(f"File {self.path} already exists (overwrite is disabled).")
+        ds = Dataset(self.path, 'w')
+        ds.createDimension('labels_zdim', shape[0])
+        ds.createDimension('labels_ydim', shape[1])
+        ds.createDimension('labels_xdim', shape[2])
+        ds.createVariable(
+            varname="labels", 
+            datatype=np.int32,
+            dimensions=('labels_zdim', 'labels_ydim', 'labels_xdim'),
+            zlib=True,
+            complevel=complevel,
+            shuffle=False,
+            chunksizes=(1, shape[1], shape[2]),
+            fill_value=-1
+        )
+        if attrs:
+            for key, val in attrs.items():
+                setattr(ds, key, val)
+        ds.close()
+        self._open_labels_nc()
+
+    def write(self, idx: int, data: np.ndarray, sync: bool = True):
+        """
+        Write a 2D data slice into the 3D label dataset at the specified index.
+
+        Args:
+            idx (int): Index along the z-dimension where the data slice will be written.
+            data (np.ndarray): 2D numpy array of shape (y, x) to write into the dataset.
+            sync (bool, optional): If True (default), flush changes to disk immediately. Always flushes on the last slice.
+
+        Behaviour:
+            Overwrites the specified z-slice in the NetCDF variable 'labels' with the provided data.
+        """
+        assert data.shape == self._shape[1:], f"Data shape {data.shape} does not match expected shape {self._shape[1:]}"
+        self._labels_arr[idx] = data
+        # Flush on request or on last slice
+        if sync or (idx == self._shape[0] - 1):
+            self.sync()
+    
+    def write_block(
+        self, 
+        data: np.ndarray, 
+        offset: Tuple[int] = (0, 0, 0), 
+        sync: bool = True
+    ):
+        """
+        Write a 3D data block into the label dataset starting at the specified index.
+
+        Args:
+            start_idx (tuple): A tuple of (z_start, y_start, x_start) specifying where to write the data block.
+            data (np.ndarray): 3D numpy array of shape (z, y, x) to write into the dataset.
+            sync (bool, optional): If True (default), flush changes to disk immediately after writing.
+
+        Behaviour:
+            Overwrites a sub-volume in the NetCDF variable 'labels' with the provided data block.
+        """
+        z_start, y_start, x_start = offset
+        z_end = z_start + data.shape[0]
+        y_end = y_start + data.shape[1]
+        x_end = x_start + data.shape[2]
+        data_mask = data > 0
+        if np.any(data_mask):
+            write_target = self._labels_arr[z_start:z_end, y_start:y_end, x_start:x_end]
+            # netCDF4 returns a copy for slices, so mutate then assign back explicitly
+            write_target[data_mask] = data[data_mask]
+            self._labels_arr[z_start:z_end, y_start:y_end, x_start:x_end] = write_target
+        if sync:
+            self.sync()
+    
+    def replace(self, idx: int, src: int, dst: int):
+        """
+        Replace all occurrences of a label value within a 2D slice of the dataset.
+
+        Args:
+            idx (int): Index along the z-dimension specifying which slice to modify.
+            src (int): Source label value to be replaced.
+            dst (int): Destination label value to replace the source with.
+
+        Behaviour:
+            Scans the specified z-slice in the NetCDF variable 'labels' and replaces
+            all pixels with value `src` by `dst`. The modification is performed in-place.
+        """
+        self._labels_arr[idx] = xr.where(self._labels_arr[idx] == src, dst, self._labels_arr[idx])
+    
+    def sync(self):
+        """
+        Flush any pending changes in the dataset to disk.
+
+        Behaviour:
+            Ensures that all modifications made to the NetCDF variable 'labels'
+            are written to disk, keeping the on-disk data consistent with memory.
+            Useful after multiple write or correct operations.
+        """
+        self._dataset.sync()
+
+    def close(self):
+        """
+        Finalize and close the NetCDF label file.
+
+        Ensures all data is flushed to disk and resources are released. Safe to call multiple times.
+        """
+        if self._dataset:
+            self._dataset.sync()
+            self._dataset.close()
+            self._dataset = None
+            self._labels_arr = None
+
+    def _open_labels_nc(self):
+        """
+        Open an existing NetCDF label file in read/write mode and initialize internal arrays.
+
+        This method is called automatically when opening an existing file or after creating a new one,
+        setting up the internal dataset and reference to the 'labels' variable for writing.
+        """
+        if not self._dataset:
+            self._dataset = Dataset(self.path, 'r+')
+            self._labels_arr = self._dataset['labels']
+            self._shape = self._labels_arr.shape

particle_pack_tools-0.0.7/pptools/preprocess.py

@@ -0,0 +1,82 @@
+import numpy as np
+import dask.array as da
+from skimage.util import view_as_blocks
+from numba import njit
+
+@njit
+def _get_bboxes_helper(_mask, _max_label, _offset):
+    """
+    Compute bounding boxes for labelled regions in a 3D mask array.
+
+    :param ndarray _mask: 3D array where each voxel is labelled with an integer.
+    :param int _max_label: Maximum number of labels.
+    :param list _offset: Offset to adjust the bounding box coordinates.
+    :return: Array of bounding boxes with shape (1, _max_label, 6), each as [x_min, y_min, z_min, x_max, y_max, z_max].
+    :rtype: ndarray
+    """
+    bboxes = np.full((1, _max_label, 6), 32767, dtype=np.int16)
+    bboxes[..., 3:] = -1
+    for x in range(_mask.shape[0]):
+        for y in range(_mask.shape[1]):
+            for z in range(_mask.shape[2]):
+                label = _mask[x, y, z]
+                if label < _max_label:  # 0 is background
+                    x_min, y_min, z_min, x_max, y_max, z_max = bboxes[0, label]
+                    real_x = x + _offset[0]
+                    real_y = y + _offset[1]
+                    real_z = z + _offset[2]
+                    bboxes[0, label, 0] = min(x_min, real_x)
+                    bboxes[0, label, 1] = min(y_min, real_y)
+                    bboxes[0, label, 2] = min(z_min, real_z)
+                    bboxes[0, label, 3] = max(x_max, real_x)
+                    bboxes[0, label, 4] = max(y_max, real_y)
+                    bboxes[0, label, 5] = max(z_max, real_z)
+    return bboxes
+
+def get_bboxes_helper(mask, max_label, block_info=None):
+    """
+    Compute bounding boxes for a 3D mask using Dask block metadata.
+
+    :param ndarray mask: 3D array where each voxel is labelled with an integer.
+    :param int max_label: Maximum label number.
+    :param dict block_info: Dask block information to compute offsets.
+    :return: Array of bounding boxes for the provided mask block.
+    :rtype: ndarray
+    """
+    offset = [loc[0] for loc in block_info[0]['array-location']]
+    return _get_bboxes_helper(mask, _max_label=max_label, _offset=offset)
+
+def get_bboxes(arr, max_label=10_000):
+    """
+    Aggregate bounding boxes from a Dask array across all blocks.
+
+    :param ndarray arr: 3D array with labelled regions.
+    :return: Aggregated array of bounding boxes, each as [x_min, y_min, z_min, x_max, y_max, z_max].
+    :rtype: ndarray
+    """
+    blocked_res = da.map_blocks(get_bboxes_helper, arr, max_label=max_label, chunks=(1, max_label, 6), dtype=np.int16).compute()
+    res_reshaped = view_as_blocks(blocked_res, block_shape=(1, max_label, 6)).reshape(-1, max_label, 6)
+    res_arr = np.empty((max_label, 6), dtype=np.int16)
+    res_arr[:, :3] = np.min(res_reshaped[:, :, :3], axis=0)
+    res_arr[:, 3:] = np.max(res_reshaped[:, :, 3:], axis=0)
+    return res_arr
+
+def crop_3d(arr, loc, padding=0):
+    """
+    Crop a 3D array to the specified bounding box with optional padding.
+
+    :param ndarray arr: 3D array to crop.
+    :param tuple loc: Bounding box coordinates as (z_min, x_min, y_min, z_max, x_max, y_max).
+    :param int padding: Number of voxels to pad around the bounding box.
+    :return: Cropped 3D array.
+    :rtype: ndarray
+    """
+    if padding == 0:
+        return arr[loc[0]:loc[3] + 1, loc[1]:loc[4] + 1, loc[2]:loc[5] + 1]
+    z_min = max(loc[0] - padding, 0)
+    x_min = max(loc[1] - padding, 0)
+    y_min = max(loc[2] - padding, 0)
+    z_max = min(loc[3] + padding, arr.shape[0] - 1)
+    x_max = min(loc[4] + padding, arr.shape[1] - 1)
+    y_max = min(loc[5] + padding, arr.shape[2] - 1)
+    return arr[z_min:z_max + 1, x_min:x_max + 1, y_min:y_max + 1]

particle_pack_tools-0.0.7/pptools/visualize.py

@@ -0,0 +1,244 @@
+import numpy as np
+
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from matplotlib.colors import ListedColormap
+import matplotlib.colors as mcolors
+from matplotlib.widgets import Slider
+from skimage.transform import resize
+
+class Visualizer:
+    @staticmethod
+    def create_mask_cmap(n, cmap='gist_rainbow', seed: int = None):
+        """
+        Create a custom color map that plots n colors, while leaving the background black
+        """
+        original_cmap = colormaps[cmap]
+        colors = np.linspace(0, 1, n - 1)
+        if seed is not None:
+            np.random.seed(seed)
+            np.random.shuffle(colors)
+        cmap_colors = original_cmap(colors)
+        black = np.array([[0, 0, 0, 1]])
+        cmap_colors = np.concatenate((black, cmap_colors))
+        return ListedColormap(cmap_colors)
+
+    def __init__(self, cmap='gist_rainbow', n_colors=32768, seed=42, latex=False):
+        if latex:
+            text_color = 'black'
+            plt.style.use('default')
+            plt.rcParams['text.color'] = text_color
+            plt.rcParams['axes.labelcolor'] = text_color
+            plt.rcParams['xtick.color'] = text_color
+            plt.rcParams['ytick.color'] = text_color
+            plt.rcParams['axes.edgecolor'] = text_color
+            plt.rcParams['font.family'] = 'Computer Modern'
+            plt.rcParams['mathtext.fontset'] = 'cm'
+            plt.rcParams['text.usetex'] = True
+            plt.rcParams['text.latex.preamble'] = r'\usepackage{amsmath}'
+        else:
+            mpl.rcParams.update(mpl.rcParamsDefault)
+        self.tomo_cmap = 'gray'
+        self.mask_cmap = Visualizer.create_mask_cmap(n_colors, cmap=cmap, seed=seed)
+        self.mask_cmap_norm = mcolors.Normalize(vmin=0, vmax=n_colors)
+        self.sliders = []
+
+    def plot_tomo(self, tomo, alpha=1, show_ticks=False, ax=None):
+        """
+        Plot a tomogram.
+
+        Parameters:
+        - tomo: The tomogram to be plotted.
+        - alpha: The transparency level of the image.
+        - show_ticks: Whether to show the xy ticks.
+        - ax: The axis to plot on. If None, use the current axis.
+        """
+        if ax is None:
+            if not show_ticks:
+                plt.gca().set_axis_off()
+            plt.imshow(tomo, alpha=alpha, cmap=self.tomo_cmap, interpolation='none')
+        else:
+            if not show_ticks:
+                plt.gca().set_axis_off()
+            return ax.imshow(tomo, alpha=alpha, cmap=self.tomo_cmap, interpolation='none', rasterized=True)
+
+    def plot_mask(self, mask, max_mask_val=None, alpha=1, show_ticks=False, ax=None):
+        """
+        Plot a mask image.
+
+        Parameters:
+        - mask: The mask data to be plotted.
+        - alpha: The transparency level of the image.
+        - show_ticks: Whether to show the xy ticks.
+        - ax: The axis to plot on. If None, use the current axis.
+        """
+        if max_mask_val is not None:
+            mask = mask.copy()
+            mask[mask > max_mask_val] = 0 
+        if ax is None:
+            if not show_ticks:
+                plt.gca().set_axis_off()
+            plt.imshow(mask, alpha=alpha, cmap=self.mask_cmap, norm=self.mask_cmap_norm, interpolation='none', rasterized=True)
+        else:
+            if not show_ticks:
+                plt.gca().set_axis_off()
+            return ax.imshow(mask, alpha=alpha, cmap=self.mask_cmap, norm=self.mask_cmap_norm, interpolation='none', rasterized=True)
+
+
+    def compare_tomo_mask(self, tomo, mask, figsize=(10, 5), show_ticks=False, stacked=True):
+        """
+        Compare a tomogram with a mask.
+        The mask will be plotted on top of the tomogram.
+
+        Parameters:
+        - tomo: The tomography data to be plotted.
+        - mask: The mask data to be plotted.
+        - figsize: The size of the figure.
+        - show_ticks: Whether to show the xy ticks.
+        - stacked: Whether to stack the images on top of each other or displayed in a row.
+        """
+        if stacked:
+            fig, ax = plt.subplots(figsize=figsize)
+            self.plot_tomo(tomo, show_ticks=show_ticks, ax=ax)
+            top_im = self.plot_mask(mask, show_ticks=show_ticks, ax=ax)
+            slider_ax = plt.axes([0.2, 0, 0.6, 0.04])
+            slider = Slider(slider_ax, '', 0, 1, valinit=0.5)
+            def _update(val):
+                top_im.set_alpha(slider.val)
+                fig.canvas.draw_idle()
+            slider.on_changed(_update)
+        else:
+            fig, ax = plt.subplots(1, 2, figsize=figsize)
+            self.plot_tomo(tomo, ax=ax[0], show_ticks=show_ticks)
+            self.plot_mask(mask, ax=ax[1], show_ticks=show_ticks)
+        self.show()
+
+    def compare_masks(self, *masks, figsize=(10, 5), show_ticks=False, stacked=True):
+        """
+        Compare multiple masks.
+        The masks can be stacked on top of each other with sliders to adjust transparency, or displayed side by side.
+
+        Parameters:
+        - masks: The masks to be compared. At least two masks are required.
+        - figsize: The size of the figure.
+        - show_ticks: Whether to show the xy ticks.
+        - stacked: Whether to stack the images on top of each other or display them side by side.
+        """
+        if len(masks) < 2:
+            raise ValueError("At least two masks are required.")
+        if stacked:
+            n_sliders = len(masks) - 1
+            slider_height = 0.04
+            gap = 0.01
+            total_slider_height = n_sliders * (slider_height + gap)
+            fig, ax = plt.subplots(1, 1, figsize=figsize)
+            fig.subplots_adjust(bottom=total_slider_height + 0.05)
+            # Plot the base mask.
+            self.plot_mask(masks[0], ax=ax, show_ticks=show_ticks)
+            for i, mask in enumerate(masks[1:]):
+                im = self.plot_mask(mask, ax=ax, show_ticks=show_ticks)
+                slider_ax = fig.add_axes([0.2, 0.05 + (n_sliders - i - 1)*(slider_height + gap), 0.6, slider_height])
+                slider = Slider(slider_ax, f'mask {i+1}', 0, 1, valinit=0.5)
+                def update(val, im=im):
+                    im.set_alpha(val)
+                    fig.canvas.draw_idle()
+                slider.on_changed(update)
+                self.sliders.append(slider)
+            self.show()
+        else:
+            n_axes = len(masks)
+            fig, axes = plt.subplots(1, n_axes, figsize=figsize)
+            for ax, mask in zip(axes, masks):
+                self.plot_mask(mask, ax=ax, show_ticks=show_ticks)
+            self.show()
+
+    def compare_tomo_mask_pred(self, tomo, mask, pred):
+        fig, ax = plt.subplots(1, 3, figsize=(15, 5))
+        self.plot_tomo(tomo, ax=ax[0])
+        self.plot_mask(mask, ax=ax[1])
+        self.plot_mask(pred, ax=ax[2])
+        plt.show()
+
+    def plot_tomo_stack(self, tomo_stack, figsize=(10, 10), downscale=False):
+        """
+        Visualise a tomogram stack with a slider.
+
+        Note: Using Dask array directly as input can significantly slow down 
+        drawing performance. It is recommended to load the Dask array in advance 
+        before using this function.
+
+        Parameters:
+        - tomo_stack: 3D numpy array of slices.
+        - figsize   : Figure size.
+        - downscale : If True, each slice is downscaled to 300*300.
+        """
+        n_slices = tomo_stack.shape[0]
+        fig, ax = plt.subplots(figsize=figsize)
+        plt.subplots_adjust(bottom=0.25)
+        if downscale:
+            slice0 = resize(np.array(tomo_stack[0]), (300, 300), mode='reflect', anti_aliasing=True)
+        else:
+            slice0 = np.array(tomo_stack[0])
+        im = self.plot_tomo(slice0, show_ticks=False, ax=ax)
+        ax.set_title("Slice 0")
+        slider_ax = fig.add_axes([0.2, 0, 0.6, 0.03])
+        slider = Slider(slider_ax, 'Slice', 0, n_slices - 1, valinit=0, valfmt='%d', valstep=1)
+        def update(val):
+            idx = int(slider.val)
+            if downscale:
+                slice_img = resize(np.array(tomo_stack[idx]), (300, 300), mode='reflect', anti_aliasing=True)
+            else:
+                slice_img = np.array(tomo_stack[idx])
+            im.set_data(slice_img)
+            ax.set_title(f"Slice {idx}")
+            fig.canvas.draw_idle()
+            del slice_img
+        slider.on_changed(update)
+        self.sliders.append(slider)
+        self.show()
+    
+    def plot_mask_stack(self, mask_stack, figsize=(10, 10), downscale=False):
+        """
+        Visualise a mask stack with a slider.
+
+        Note: Using Dask array directly as input can significantly slow down 
+        drawing performance. It is recommended to load the Dask array in advance 
+        before using this function.
+        
+        Parameters:
+        - tomo_stack: 3D numpy array of slices.
+        - figsize   : Figure size.
+        - downscale : If True, each slice is downscaled to 300*300.
+        """
+        n_slices = mask_stack.shape[0]
+        fig, ax = plt.subplots(figsize=figsize)
+        plt.subplots_adjust(bottom=0.25)
+        if downscale:
+            slice0 = np.array(mask_stack[0]).astype(np.float32)
+            slice0 = resize(slice0, (300, 300), mode='reflect', anti_aliasing=False)
+        else:
+            slice0 = mask_stack[0]
+        im = self.plot_mask(slice0, show_ticks=False, ax=ax)
+        ax.set_title("Slice 0")
+        slider_ax = fig.add_axes([0.2, 0, 0.6, 0.03])
+        slider = Slider(slider_ax, 'Slice', 0, n_slices - 1, valinit=0, valfmt='%d', valstep=1)
+        def update(val):
+            idx = int(slider.val)
+            if downscale:
+                slice_img = np.array(mask_stack[idx]).astype(np.float32)
+                slice_img = resize(slice_img, (300, 300), mode='reflect', anti_aliasing=False)
+            else:
+                slice_img = mask_stack[idx]
+            im.set_data(slice_img)
+            ax.set_title(f"Slice {idx}")
+            fig.canvas.draw_idle()
+        slider.on_changed(update)
+        self.sliders.append(slider)
+        self.show()
+    
+    def figsize(self, figsize=(10, 10)):
+        plt.figure(figsize=figsize)
+
+    def show(self):
+        plt.show()

particle_pack_tools-0.0.7/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "particle-pack-tools"
+version = "0.0.7"
+authors = [
+    { name = "Bogong Wang", email = "bogongwang.dev@outlook.com" }
+]
+description = "A toolkit for processing and visualizing particle pack data."
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+keywords = ["particle pack", "tools", "visualization", "data processing", "particle pack"]
+
+dependencies = [
+    "xarray>=2025.1",
+    "dask>=2025.1",
+    "netCDF4>=1.7.2",
+    "scikit-image>=0.25.0",
+    "scipy>=1.15.0",
+    "numpy>=1.25.0",
+    "numba>=0.60.0",
+    "matplotlib>=3.10.0"
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+test = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/bogongwang/particle-pack-tools"
+Repository = "https://github.com/bogongwang/particle-pack-tools"

particle_pack_tools-0.0.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+