pydoug-core 0.1.0__tar.gz

pydoug_core-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+build/
+dist/
+.coverage
+
+packages/pydoug-core/src/pydoug_core/_manifest.py
+packages/pydoug-core/src/pydoug_core/__pycache__/
+packages/pydoug-core/src/pydoug_core/analyze/__pycache__/
+packages/pydoug-core/src/pydoug_core/batch/__pycache__/
+packages/pydoug-core/src/pydoug_core/color/__pycache__/
+packages/pydoug-core/src/pydoug_core/detect/__pycache__/
+packages/pydoug-core/src/pydoug_core/filter/__pycache__/
+packages/pydoug-core/src/pydoug_core/gen/__pycache__/
+packages/pydoug-core/src/pydoug_core/hist/__pycache__/
+packages/pydoug-core/src/pydoug_core/io/__pycache__/
+packages/pydoug-core/src/pydoug_core/manipulate/__pycache__/
+packages/pydoug-core/src/pydoug_core/math/__pycache__/
+packages/pydoug-core/src/pydoug_core/morph/__pycache__/
+packages/pydoug-core/src/pydoug_core/restore/__pycache__/
+packages/pydoug-core/src/pydoug_core/segment/__pycache__/
+packages/pydoug-core/src/pydoug_core/trans/__pycache__/
+packages/pydoug-core/src/pydoug_core/user/__pycache__/
+packages/pydoug-core/tests/__pycache__/
+packages/pydoug-core/tests/test_analyze/__pycache__/
+packages/pydoug-core/tests/test_batch/__pycache__/
+packages/pydoug-core/tests/test_color/__pycache__/
+packages/pydoug-core/tests/test_detect/__pycache__/
+packages/pydoug-core/tests/test_filter/__pycache__/
+packages/pydoug-core/tests/test_gen/__pycache__/
+packages/pydoug-core/tests/test_hist/__pycache__/
+packages/pydoug-core/tests/test_io/__pycache__/
+packages/pydoug-core/tests/test_manipulate/__pycache__/
+packages/pydoug-core/tests/test_math/__pycache__/
+packages/pydoug-core/tests/test_morph/__pycache__/
+packages/pydoug-core/tests/test_restore/__pycache__/
+packages/pydoug-core/tests/test_segment/__pycache__/
+packages/pydoug-core/tests/test_trans/__pycache__/
+packages/pydoug-core/tests/test_user/__pycache__/
+
+packages/pydoug-napari/src/pydoug_napari/__pycache__
+packages/pydoug-napari/src/pydoug_napari/_operations/_manifest.py
+packages/pydoug-napari/src/pydoug_napari/_operations/__pycache__/
+packages/pydoug-napari/src/pydoug_napari/_widgets/__pycache__
+packages/pydoug-napari/tests/__pycache__
+packages/pydoug-napari/tests/test_operations/__pycache__/
+packages/pydoug-napari/tests/test_widgets/__pycache__
+
+packages/pydoug-standalone/src/pydoug_standalone/__pycache__/
+packages/pydoug-standalone/src/pydoug_standalone/hooks/__pycache__/
+
+scripts/__pycache__/

pydoug_core-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026, Douglas Lars Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pydoug_core-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.5
+Name: pydoug-core
+Version: 0.1.0
+Summary: Core I/O, image processing and analysis, and batch logic for PyDoug
+Project-URL: Homepage, https://github.com/LarsN-hub/PyDoug2
+Project-URL: Issues, https://github.com/LarsN-hub/PyDoug2/issues
+Author-email: Douglas Lars Nelson <PyDoug@referable.anonaddy.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: image processing,image segmentation,microscopy,scientific imaging,tomography
+Requires-Python: >=3.13
+Requires-Dist: algotom==1.7.0
+Requires-Dist: cmasher==1.9.2
+Requires-Dist: h5py==3.16.0
+Requires-Dist: imageio==2.37.4
+Requires-Dist: matplotlib==3.11.1
+Requires-Dist: numba==0.67.0
+Requires-Dist: numpy==2.5.2
+Requires-Dist: openpnm==3.6.4
+Requires-Dist: porespy==3.1.0
+Requires-Dist: psygnal==0.15.1
+Requires-Dist: scikit-image==0.26.0
+Requires-Dist: scipy==1.18.0
+Provides-Extra: testing
+Requires-Dist: pytest-cov==7.1.0; extra == 'testing'
+Requires-Dist: pytest==9.1.1; extra == 'testing'
+Description-Content-Type: text/markdown
+
+This is the core functionality subpackage for the full PyDoug image processing software package. Visit https://github.com/LarsN-hub/PyDoug2 for the full package README.md.

pydoug_core-0.1.0/README.md

@@ -0,0 +1 @@
+This is the core functionality subpackage for the full PyDoug image processing software package. Visit https://github.com/LarsN-hub/PyDoug2 for the full package README.md.

pydoug_core-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pydoug-core"
+version = "0.1.0"
+description = "Core I/O, image processing and analysis, and batch logic for PyDoug"
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+authors = [
+    {name = "Douglas Lars Nelson", email = "PyDoug@referable.anonaddy.com"}
+]
+keywords = [
+    "image processing",
+    "image segmentation",
+    "microscopy",
+    "tomography",
+    "scientific imaging",
+]
+dependencies = [
+    "algotom==1.7.0",
+    "cmasher==1.9.2",
+    "h5py==3.16.0",
+    "ImageIO==2.37.4",
+    "matplotlib==3.11.1",
+    "numba==0.67.0",
+    "numpy==2.5.2",
+    "openpnm==3.6.4",
+    "porespy==3.1.0",
+    "psygnal==0.15.1",
+    "scikit-image==0.26.0",
+    "scipy==1.18.0",
+]
+
+[project.optional-dependencies]
+testing = [
+    "pytest==9.1.1",
+    "pytest-cov==7.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/LarsN-hub/PyDoug2"
+Issues = "https://github.com/LarsN-hub/PyDoug2/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pydoug_core"]

pydoug_core-0.1.0/src/pydoug_core/__init__.py

@@ -0,0 +1,24 @@
+"""
+Auto-imports every module in this package for discovery by widget registry.
+"""
+
+import importlib
+import sys
+
+if getattr(sys, "frozen", False):  # pragma: no cover
+    from pydoug_core._manifest import OPERATION_MODULES
+
+    for name in OPERATION_MODULES:
+        importlib.import_module(name)
+else:
+    import pkgutil
+
+    _NOT_OPERATIONS: set[str] = {"pydoug_core.testing"}
+
+    for _, module_name, _ in pkgutil.walk_packages(__path__, prefix=f"{__name__}."):
+        if (
+            module_name.rsplit(".", 1)[-1].startswith("_")
+            or module_name in _NOT_OPERATIONS
+        ):
+            continue
+        importlib.import_module(module_name)

pydoug_core-0.1.0/src/pydoug_core/_manifest.py

@@ -0,0 +1,2 @@
+# Auto-generated by scripts/generate_manifests.py - DO NOT EDIT!
+OPERATION_MODULES = ['pydoug_core.analyze', 'pydoug_core.analyze.compare', 'pydoug_core.analyze.image_info', 'pydoug_core.analyze.measure', 'pydoug_core.analyze.plot_distrib', 'pydoug_core.analyze.plot_util', 'pydoug_core.batch', 'pydoug_core.batch.recorder', 'pydoug_core.batch.runner', 'pydoug_core.color', 'pydoug_core.color.cspace', 'pydoug_core.detect', 'pydoug_core.detect.shapes', 'pydoug_core.detect.sharp', 'pydoug_core.detect.texture', 'pydoug_core.filter', 'pydoug_core.filter.blur', 'pydoug_core.filter.edge', 'pydoug_core.filter.other', 'pydoug_core.filter.pass_band', 'pydoug_core.filter.ridge', 'pydoug_core.gen', 'pydoug_core.gen.gen', 'pydoug_core.hist', 'pydoug_core.hist.hist', 'pydoug_core.io', 'pydoug_core.io.imreader', 'pydoug_core.io.imwriter', 'pydoug_core.io.io_util', 'pydoug_core.manipulate', 'pydoug_core.manipulate.crop', 'pydoug_core.manipulate.dims', 'pydoug_core.math', 'pydoug_core.math.arithmetic', 'pydoug_core.math.logic', 'pydoug_core.morph', 'pydoug_core.morph.features', 'pydoug_core.morph.morph', 'pydoug_core.payloads', 'pydoug_core.registry', 'pydoug_core.restore', 'pydoug_core.restore.denoise', 'pydoug_core.restore.misc', 'pydoug_core.results', 'pydoug_core.segment', 'pydoug_core.segment.intensity', 'pydoug_core.segment.label', 'pydoug_core.segment.local', 'pydoug_core.segment.rgb', 'pydoug_core.segment.segment_util', 'pydoug_core.trans', 'pydoug_core.trans.geom', 'pydoug_core.trans.space', 'pydoug_core.user', 'pydoug_core.user.user_functions', 'pydoug_core.util']

pydoug_core-0.1.0/src/pydoug_core/analyze/compare.py

@@ -0,0 +1,384 @@
+"""
+Compare two image datasets.
+"""
+
+from typing import Annotated, Literal
+
+import numpy as np
+
+from pydoug_core.registry import register_operation
+
+__all__ = ["mse", "ssi", "psnr", "are", "voi", "nmi", "intersection", "hausdorff_dist"]
+
+
+@register_operation(
+    category="compare",
+    display_name="Mean Squared Error",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def mse(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+    NRMSE: bool = False,
+    Normalization_Method: Literal["Euclidean", "Min-Max", "Mean"] = "Euclidean",
+) -> float:
+    """
+    Calculate the mean squared error (MSE) between two images. Images must have the same
+    dimensions but can be 2D/3D grayscale/RGB. Useful for judging intensity differences
+    between images. Ranges from 0 (perfectly identical images) upwards (higher = less
+    similar). Convenience wrapper around scikit-image's metrics.mean_squared_error and
+    metrics.normalized_root_mse:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.mean_squared_error
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.normalized_root_mse
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The ground-truth image.
+    Layer2: np.ndarray
+        The image to test against the ground-truth image.
+    NRMSE: bool
+        Whether to compute the normalized root MSE (True) or standard MSE (False).
+        Default is False.
+    Normalization_Method: Literal
+        The normalization method to use if "NRMSE" is "True". Ignored otherwise. Default
+        is "Euclidean".
+        - "Euclidean": Normalize by averaged Euclidean norm of ground-truth image.
+        - "Min-Max": Normalize by intensity range of ground-truth image.
+        - "Mean": Normalize by mean of ground-truth image.
+
+    Returns
+    -------
+    mse_val: float
+        The MSE between the two images.
+    """
+
+    if NRMSE:
+        from skimage.metrics import normalized_root_mse
+
+        return normalized_root_mse(
+            imarray, Layer2, normalization=Normalization_Method.lower()
+        )
+
+    from skimage.metrics import mean_squared_error
+
+    return mean_squared_error(imarray, Layer2)
+
+
+@register_operation(
+    category="compare",
+    display_name="Structural Similarity",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def ssi(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+) -> float:
+    """
+    Calculate the structural similarity index (SSI) between two images. Images must have
+    the same dimensions but can be 2D/3D grayscale/RGB. Useful for judging intensity and
+    texture differences between images. Ranges from 1 (identical images) to 0 (perfectly
+    non-similar images). Convenience wrapper around scikit-image's
+    metrics.structural_similarity:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.structural_similarity
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The first image.
+    Layer2: np.ndarray
+        The second image.
+
+    Returns
+    -------
+    ssi_val: float
+        The SSI between the two images.
+    """
+
+    from skimage.metrics import structural_similarity
+
+    from pydoug_core.util import chan_axis
+
+    if imarray.dtype == np.bool:
+        imrange: float | int = 1
+    else:
+        imrange = np.max(imarray) - np.min(imarray)
+
+    return structural_similarity(
+        imarray,
+        Layer2,
+        data_range=imrange,
+        channel_axis=chan_axis(imarray),
+    )  # type: ignore
+
+
+@register_operation(
+    category="compare",
+    display_name="Peak Signal to Noise Ratio",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def psnr(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+) -> float:
+    """
+    Calculate the peak signal to noise ratio (PSNR) between two images. Images must be
+    the same dimension but can be 2D/3D grayscale/RGB. Ratio of the peak signal of an
+    image to the corrupting noise present (higher = better, PSNR -> infinity if both
+    images are identical). Convenience wrapper around scikit-image's
+    metrics.peak_signal_noise_ratio:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.peak_signal_noise_ratio
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The ground-truth image.
+    Layer2: np.ndarray
+        The image to test against the ground-truth image.
+
+    Returns
+    -------
+    psnr_val: float
+        The PSNR between the two images.
+    """
+
+    from skimage.metrics import peak_signal_noise_ratio
+
+    if imarray.dtype == np.bool:
+        imrange: float | int = 1
+    else:
+        imrange = np.max(imarray) - np.min(imarray)
+
+    return peak_signal_noise_ratio(imarray, Layer2, data_range=imrange)
+
+
+@register_operation(
+    category="compare",
+    display_name="Adapted Rand Error",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def are(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+) -> dict[str, float]:
+    """
+    Calculate the adapted Rand error between an image and a ground-truth image. Images
+    must have the same dimensions but can be 2D/3D grayscale/RGB. Useful for evaluating
+    segmentation similarity. Returns "Error", "Precision", and "Recall", where "Error"
+    indicates overall similarity (0 = perfectly similar). "Precision" is the number of
+    correctly segmented pixels divided by the number of segmented pixels in the test
+    image and "Recall" is the number of correctly segmented pixels divided by the number
+    of segmented pixels in the true image. If "Precision" is close to 1 but "Recall" is
+    lower, the image is undersegmented. If "Recall" is close to 1 but "Precision" is
+    lower, the image is oversegmented. Both are 1 for perfect segmentation. Non-integer
+    images are converted before calculation. Convenience wrapper around scikit-image's
+    metrics.adapted_rand_error:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.adapted_rand_error
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The ground truth image.
+    Layer2: np.ndarray
+        The image to test against the ground truth image.
+
+    Returns
+    -------
+    are_dict:
+        The adapted Rand error, precision, and recall between the two images.
+    """
+
+    from skimage.metrics import adapted_rand_error
+
+    are, prec, rec = adapted_rand_error(
+        np.round(imarray).astype(np.int32), np.round(Layer2).astype(np.int32)
+    )
+
+    return {"Error": are, "Precision": prec, "Recall": rec}
+
+
+@register_operation(
+    category="compare",
+    display_name="Variation of Information",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def voi(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+    Rounding_Decimals: Annotated[int, {"min": 0}] = 5,
+) -> dict[str, float]:
+    """
+    Calculate the variation of information (VOI) between two images. Images must have
+    the same dimensions but can be 2D/3D grayscale/RGB. Useful for assessing over/under
+    segmentation with a ground-truth image. Returns "Splits" and "Merges" where "Splits"
+    indicates undersegmentation while "Merges" indicates oversegmentation. 0 = perfect
+    similarity while higher means less similar. Non-integer images are converted before
+    calculation. Convenience wrapper around scikit-image's
+    metrics.variation_of_information:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.variation_of_information
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The ground-truth image.
+    Layer2: np.ndarray
+        The image to compare to the ground-truth image.
+    Rounding_Decimals: int
+        The number of decimal points to round to (returns 0 if truly perfect instead of
+        just a very small number). Default is 5, increase for more decimals points.
+
+    Returns
+    -------
+    voi_vals: dict[str, float]
+        A dictionary containing the splits and merges from the VOI calculation.
+    """
+
+    from skimage.metrics import variation_of_information
+
+    splits, merges = variation_of_information(
+        np.round(imarray).astype(np.int32),
+        np.round(Layer2).astype(np.int32),
+    )
+
+    return {
+        "Splits": round(splits, Rounding_Decimals),
+        "Merges": round(merges, Rounding_Decimals),
+    }
+
+
+@register_operation(
+    category="compare",
+    display_name="Normalized Mutual Information",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def nmi(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+    Bin_Count: Annotated[int, {"min": 1}] = 100,
+    Rounding_Decimals: Annotated[int, {"min": 0}] = 5,
+) -> float:
+    """
+    Calculate the normalized mutual information (NMI) between two images. Images must
+    have the same dimensions but can be 2D/3D grayscale/RGB. Useful for assessing image
+    registration quality (higher = better). Measured from 1 to 2 where 2 = perfect
+    correlation and 1 = perfect non-correlation. Convenience wrapper around
+    scikit-image's metrics.normalized_mutual_information:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.normalized_mutual_information
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The first image.
+    Layer2: np.ndarray
+        The second image.
+    Bin_Count: int
+        The number of bins to use to calculate the joint histogram.
+    Rounding_Decimals: int
+        The number of decimal points to round to (returns 0 if truly perfect instead of
+        just a very small number). Default is 5, increase for more decimals points.
+
+    Returns
+    -------
+    nmi_val: float
+        The NMI between the two images.
+    """
+
+    from skimage.metrics import normalized_mutual_information
+
+    return round(
+        normalized_mutual_information(imarray, Layer2, bins=Bin_Count),  # type: ignore
+        Rounding_Decimals,
+    )
+
+
+@register_operation(
+    category="compare",
+    display_name="Intersection Coefficient",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def intersection(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+) -> float:
+    """
+    Determine the fraction of the segmented pixels in the first image that lie within
+    the segmented pixels of the second image. Accepts 2D/3D grayscale/RGB images but is
+    only meaningful for binary segmented images. All nonzero pixels in non-binary images
+    are treated as segmented pixels. Convenience wrapper around numpy's boolean indexing
+    and count_nonzero:
+    https://numpy.org/doc/1.21/reference/arrays.indexing.html#boolean-array-indexing
+    https://numpy.org/doc/stable/reference/generated/numpy.count_nonzero.html
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The first image.
+    Layer2: np.ndarray
+        The second image.
+
+    Returns
+    -------
+    inter_coeff: float
+        The intersection coefficient between the two images.
+    """
+
+    from pydoug_core.util import convert_dtype, rgb2gray
+
+    one_total: np.intp = np.count_nonzero(convert_dtype(rgb2gray(imarray), "Bool"))
+    one_count: np.intp = np.count_nonzero(
+        convert_dtype(rgb2gray(imarray), "Bool")[
+            convert_dtype(rgb2gray(Layer2), "Bool")
+        ]
+    )
+
+    return one_count / one_total
+
+
+@register_operation(
+    category="compare",
+    display_name="Hausdorff Distance",
+    array_params=("Layer2",),
+    output_kind="value",
+    recordable_toggle=True,
+)
+def hausdorff_dist(
+    imarray: np.ndarray,
+    Layer2: np.ndarray,
+) -> float:
+    """
+    Calculate the Hausdorff distance between two images (the maximum distance between
+    a nonzero pixel in the first image and the nearest nonzero pixel in the second
+    image). Images must have the same dimensions but can be 2D/3D grayscale/RGB.
+    Convenience wrapper around scikit-image's metrics.hausdorff_distance:
+    https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.hausdorff_distance
+
+    Parameters
+    ----------
+    imarray: np.ndarray
+        The first image.
+    Layer2: np.ndarray
+        The second image.
+
+    Returns
+    -------
+    hd_val: float
+        The Hausdorff distance between the two images.
+    """
+
+    from skimage.metrics import hausdorff_distance
+
+    return hausdorff_distance(imarray, Layer2)  # type: ignore