napari-myelin-quantifier 0.1.0__py3-none-any.whl

napari_myelin_quantifier/__init__.py

@@ -0,0 +1,8 @@
+try:
+    from ._version import version as __version__
+except ImportError:
+    __version__ = "unknown"
+
+from ._widget import myelin_quantifier_widget
+
+__all__ = ["myelin_quantifier_widget"]

napari_myelin_quantifier/_axon_quant.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import pandas as pd
+from scipy import ndimage as ndi
+from skimage import morphology
+from skimage.color import rgb2hsv
+from skimage.measure import label, regionprops
+from skimage.segmentation import clear_border
+
+
+@dataclass
+class QuantParams:
+    px_size_um: float = 0.02
+
+    # Myelin extraction / cleanup
+    v_thresh: float = 0.15
+    min_myelin_obj: int = 30
+    close_radius: int = 3
+    open_radius: int = 1
+
+    # Axon interior filtering
+    min_axon_area: int = 150
+    min_solidity: float = 0.60
+
+    # Edge handling
+    remove_border_objects: bool = True
+    edge_margin_px: int = 8
+
+    # Optional crop for screenshots with UI borders
+    auto_crop: bool = True
+    crop_frac_thresh: float = 0.15  # fraction threshold used for content crop
+
+
+def _find_content_crop(
+    img_rgb: np.ndarray, v_thresh: float = 0.15, frac_thresh: float = 0.15
+):
+    """Auto-crop away UI/borders by finding dense colored region."""
+    hsv = rgb2hsv(img_rgb / 255.0)
+    v = hsv[..., 2]
+    mask = v > v_thresh
+
+    col_frac = mask.mean(axis=0)
+    row_frac = mask.mean(axis=1)
+
+    xs = np.where(col_frac > frac_thresh)[0]
+    ys = np.where(row_frac > frac_thresh)[0]
+
+    if len(xs) < 10 or len(ys) < 10:
+        return img_rgb, (0, 0)
+
+    x0, x1 = xs.min(), xs.max() + 1
+    y0, y1 = ys.min(), ys.max() + 1
+    return img_rgb[y0:y1, x0:x1], (y0, x0)
+
+
+def _touches_margin(bbox, H: int, W: int, margin: int) -> bool:
+    minr, minc, maxr, maxc = bbox
+    return (
+        (minr <= margin)
+        or (minc <= margin)
+        or (maxr >= H - margin)
+        or (maxc >= W - margin)
+    )
+
+
+def quantify_myelinated_axons(
+    img_rgb: np.ndarray,
+    params: QuantParams,
+) -> tuple[np.ndarray, np.ndarray, pd.DataFrame, tuple[int, int]]:
+    """
+    Returns:
+      labels_full: 2D int32 label image in full image coordinates (axon_id 1..N; 0=bg)
+      overlay_full: 3D uint8 RGB overlay in full image coordinates (boundary drawn white)
+      df: measurements table; axon_id matches labels/text
+      (y_off, x_off): crop offset applied
+    """
+    if img_rgb.ndim != 3 or img_rgb.shape[2] not in (3, 4):
+        raise ValueError(
+            f"Expected 2D RGB/RGBA image with shape (Y, X, 3/4). Got: {img_rgb.shape}"
+        )
+
+    if img_rgb.shape[2] == 4:
+        img_rgb = img_rgb[..., :3]
+
+    img_rgb = img_rgb.astype(np.uint8)
+
+    # Optional crop (useful for screenshots like your example)
+    if params.auto_crop:
+        img_c, (y_off, x_off) = _find_content_crop(
+            img_rgb,
+            v_thresh=params.v_thresh,
+            frac_thresh=params.crop_frac_thresh,
+        )
+    else:
+        img_c, (y_off, x_off) = img_rgb, (0, 0)
+
+    Hc, Wc, _ = img_c.shape
+
+    # -----------------------
+    # MYELIN MASK
+    # -----------------------
+    hsv = rgb2hsv(img_c / 255.0)
+    v = hsv[..., 2]
+    myelin = v > params.v_thresh
+
+    myelin = morphology.remove_small_objects(myelin, params.min_myelin_obj)
+    myelin = morphology.binary_closing(
+        myelin, morphology.disk(params.close_radius)
+    )
+    myelin = morphology.binary_opening(
+        myelin, morphology.disk(params.open_radius)
+    )
+
+    # -----------------------
+    # FILL HOLES (NO AREA CAP)
+    # -----------------------
+    filled = ndi.binary_fill_holes(myelin)
+    axon = filled & (~myelin)
+
+    axon = morphology.remove_small_objects(axon, params.min_axon_area)
+
+    if params.remove_border_objects:
+        axon = clear_border(axon)
+
+    # -----------------------
+    # LABEL + MEASURE
+    # -----------------------
+    lab_raw = label(axon)
+    props = regionprops(lab_raw)
+
+    rows = []
+    for p in props:
+        if params.edge_margin_px > 0 and _touches_margin(
+            p.bbox, axon.shape[0], axon.shape[1], params.edge_margin_px
+        ):
+            continue
+
+        area_px = float(p.area)
+        area_um2 = area_px * (params.px_size_um**2)
+        eq_diam_um = float(p.equivalent_diameter) * params.px_size_um
+
+        rows.append(
+            {
+                "raw_label": int(p.label),
+                "area_px": area_px,
+                "area_um2": area_um2,
+                "eq_diam_um": eq_diam_um,
+                "eccentricity": float(p.eccentricity),
+                "solidity": float(p.solidity),
+                "cy_crop": float(p.centroid[0]),
+                "cx_crop": float(p.centroid[1]),
+                "cy_img": float(p.centroid[0] + y_off),
+                "cx_img": float(p.centroid[1] + x_off),
+            }
+        )
+
+    df = pd.DataFrame(rows)
+
+    # Filter by shape (your “verified axons/myelin” gate)
+    if len(df) > 0:
+        df_f = df[
+            (df["area_px"] >= params.min_axon_area)
+            & (df["solidity"] >= params.min_solidity)
+        ].copy()
+        df_f = df_f.sort_values(["cy_img", "cx_img"]).reset_index(drop=True)
+        df_f.insert(0, "axon_id", np.arange(1, len(df_f) + 1))
+    else:
+        df_f = df.copy()
+        df_f.insert(0, "axon_id", [])
+
+    # Relabel into axon_id space (1..N) inside crop coords
+    labels_crop = np.zeros((Hc, Wc), dtype=np.int32)
+    if len(df_f) > 0:
+        raw_to_new = {
+            int(r.raw_label): int(r.axon_id)
+            for r in df_f.itertuples(index=False)
+        }
+        # Map raw labels -> new ids
+        # Fast remap via LUT
+        max_raw = int(lab_raw.max())
+        lut = np.zeros(max_raw + 1, dtype=np.int32)
+        for k, v in raw_to_new.items():
+            if 0 <= k <= max_raw:
+                lut[k] = v
+        labels_crop = lut[lab_raw].astype(np.int32)
+
+    # Boundary overlay (crop coords)
+    axon_crop_mask = labels_crop > 0
+    boundary = morphology.dilation(
+        axon_crop_mask, morphology.disk(1)
+    ) ^ morphology.erosion(axon_crop_mask, morphology.disk(1))
+    overlay_crop = img_c.copy()
+    overlay_crop[boundary] = [255, 255, 255]
+
+    # Paste back into full-size arrays
+    H, W, _ = img_rgb.shape
+    labels_full = np.zeros((H, W), dtype=np.int32)
+    overlay_full = img_rgb.copy()
+
+    labels_full[y_off : y_off + Hc, x_off : x_off + Wc] = labels_crop
+    overlay_full[y_off : y_off + Hc, x_off : x_off + Wc] = overlay_crop
+
+    return labels_full, overlay_full, df_f, (y_off, x_off)

napari_myelin_quantifier/_reader.py

@@ -0,0 +1,85 @@
+"""
+This module is an example of a barebones numpy reader plugin for napari.
+
+It implements the Reader specification, but your plugin may choose to
+implement multiple readers or even other plugin contributions. see:
+https://napari.org/stable/plugins/building_a_plugin/guides.html#readers
+"""
+
+import numpy as np
+
+
+def napari_get_reader(path):
+    """A basic implementation of a Reader contribution.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    function or None
+        If the path is a recognized format, return a function that accepts the
+        same path or list of paths, and returns a list of layer data tuples.
+    """
+    if isinstance(path, list):
+        # reader plugins may be handed single path, or a list of paths.
+        # if it is a list, it is assumed to be an image stack...
+        # so we are only going to look at the first file.
+        path = path[0]
+
+    # the get_reader function should make as many checks as possible
+    # (without loading the full file) to determine if it can read
+    # the path. Here, we check the dtype of the array by loading
+    # it with memmap, so that we don't actually load the full array into memory.
+    # We pretend that this reader can only read integer arrays.
+    try:
+        arr = np.load(path, mmap_mode="r")
+        if arr.dtype != np.int_:
+            return None
+    # napari_get_reader should never raise an exception, because napari
+    # raises its own specific errors depending on what plugins are
+    # available for the given path, so we catch
+    # the OSError that np.load might raise if the file is malformed
+    except OSError:
+        return None
+
+    # otherwise we return the *function* that can read ``path``.
+    return reader_function
+
+
+def reader_function(path):
+    """Take a path or list of paths and return a list of LayerData tuples.
+
+    Readers are expected to return data as a list of tuples, where each tuple
+    is (data, [add_kwargs, [layer_type]]), "add_kwargs" and "layer_type" are
+    both optional.
+
+    Parameters
+    ----------
+    path : str or list of str
+        Path to file, or list of paths.
+
+    Returns
+    -------
+    layer_data : list of tuples
+        A list of LayerData tuples where each tuple in the list contains
+        (data, metadata, layer_type), where data is a numpy array, metadata is
+        a dict of keyword arguments for the corresponding viewer.add_* method
+        in napari, and layer_type is a lower-case string naming the type of
+        layer. Both "meta", and "layer_type" are optional. napari will
+        default to layer_type=="image" if not provided
+    """
+    # handle both a string and a list of strings
+    paths = [path] if isinstance(path, str) else path
+    # load all files into array
+    arrays = [np.load(_path) for _path in paths]
+    # stack arrays into single array
+    data = np.squeeze(np.stack(arrays))
+
+    # optional kwargs for the corresponding viewer.add_* method
+    add_kwargs = {}
+
+    layer_type = "image"  # optional, default is "image"
+    return [(data, add_kwargs, layer_type)]

napari_myelin_quantifier/_sample_data.py

@@ -0,0 +1,22 @@
+"""
+This module is an example of a barebones sample data provider for napari.
+
+It implements the "sample data" specification.
+see: https://napari.org/stable/plugins/building_a_plugin/guides.html#sample-data
+
+Replace code below according to your needs.
+"""
+
+from __future__ import annotations
+
+import numpy
+
+
+def make_sample_data():
+    """Generates an image"""
+    # Return list of tuples
+    # [(data1, add_image_kwargs1), (data2, add_image_kwargs2)]
+    # Check the documentation for more information about the
+    # add_image_kwargs
+    # https://napari.org/stable/api/napari.Viewer.html#napari.Viewer.add_image
+    return [(numpy.random.rand(512, 512), {})]

napari_myelin_quantifier/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

napari_myelin_quantifier/_widget.py

@@ -0,0 +1,152 @@
+import napari
+import numpy as np
+import pandas as pd
+from magicgui import magic_factory
+from napari.layers import Image  # <-- real class (magicgui can resolve)
+from qtpy.QtWidgets import QFileDialog
+
+from ._axon_quant import QuantParams, quantify_myelinated_axons
+
+
+def _as_uint8_rgb(data: np.ndarray) -> np.ndarray:
+    """Convert napari image data into uint8 RGB (Y,X,3)."""
+    arr = np.asarray(data)
+
+    # Expect (Y, X, 3) or (Y, X, 4)
+    if arr.ndim == 3 and arr.shape[-1] in (3, 4):
+        if arr.dtype != np.uint8:
+            a = arr.astype(np.float32)
+            a = a - np.nanmin(a)
+            denom = (np.nanmax(a) - np.nanmin(a)) + 1e-9
+            a = a / denom
+            a = (a * 255.0).clip(0, 255).astype(np.uint8)
+            arr = a
+        return arr[..., :3]
+
+    raise ValueError(
+        f"Expected RGB/RGBA image data. Got shape={arr.shape}, dtype={arr.dtype}"
+    )
+
+
+@magic_factory(
+    call_button="Run quantification",
+    # Top 3 critical knobs
+    v_thresh={
+        "label": "V-threshold (myelin brightness)",
+        "min": 0.0,
+        "max": 1.0,
+        "step": 0.01,
+    },
+    min_axon_area={
+        "label": "Min axon area (px)",
+        "min": 0,
+        "max": 20000,
+        "step": 10,
+    },
+    min_solidity={
+        "label": "Min solidity",
+        "min": 0.0,
+        "max": 1.0,
+        "step": 0.01,
+    },
+    # Secondary knobs
+    close_radius={"label": "Closing radius", "min": 0, "max": 20, "step": 1},
+    open_radius={"label": "Opening radius", "min": 0, "max": 20, "step": 1},
+    edge_margin_px={
+        "label": "Edge margin exclusion (px)",
+        "min": 0,
+        "max": 200,
+        "step": 1,
+    },
+    px_size_um={
+        "label": "Pixel size (µm/px)",
+        "min": 0.0,
+        "max": 10.0,
+        "step": 0.001,
+    },
+)
+def myelin_quantifier_widget(
+    viewer: napari.Viewer,
+    image_layer: Image,  # <-- key change
+    v_thresh: float = 0.15,
+    min_axon_area: int = 150,
+    min_solidity: float = 0.60,
+    close_radius: int = 3,
+    open_radius: int = 1,
+    edge_margin_px: int = 8,
+    px_size_um: float = 0.02,
+    remove_border_objects: bool = True,
+    auto_crop_screenshot: bool = True,
+    export_csv: bool = True,
+) -> None:
+    """
+    Runs myelinated axon quantification on an RGB image layer.
+
+    Outputs:
+      - Labels layer: axon interiors labeled 1..N (axon_id)
+      - Image layer: boundary overlay for verification
+      - Points layer: ID text anchored at centroids
+      - Optional CSV export with axon_id + measurements
+    """
+    if image_layer is None:
+        raise ValueError("Select an RGB image layer.")
+
+    img_rgb = _as_uint8_rgb(image_layer.data)
+
+    params = QuantParams(
+        px_size_um=px_size_um,
+        v_thresh=v_thresh,
+        min_axon_area=min_axon_area,
+        min_solidity=min_solidity,
+        close_radius=close_radius,
+        open_radius=open_radius,
+        remove_border_objects=remove_border_objects,
+        edge_margin_px=edge_margin_px,
+        auto_crop=auto_crop_screenshot,
+    )
+
+    labels_full, overlay_full, df, _ = quantify_myelinated_axons(
+        img_rgb, params
+    )
+
+    base = image_layer.name
+
+    # 1) Labels layer
+    viewer.add_labels(labels_full, name=f"{base} | axon_ids")
+
+    # 2) Overlay image layer
+    viewer.add_image(overlay_full, name=f"{base} | axon_overlay", opacity=0.8)
+
+    # 3) Text IDs as Points layer
+    if len(df) > 0:
+        points = df[["cy_img", "cx_img"]].to_numpy(dtype=float)  # (y,x)
+        features = pd.DataFrame(
+            {"axon_id": df["axon_id"].astype(str).to_numpy()}
+        )
+
+        pts = viewer.add_points(
+            points,
+            name=f"{base} | axon_id_text",
+            size=0,  # text only
+            features=features,
+        )
+        pts.text = {
+            "string": "{axon_id}",
+            "size": 10,
+            "color": "yellow",
+            "anchor": "center",
+        }
+
+    # 4) Export CSV
+    if export_csv:
+        default_name = f"{base}_axon_measurements.csv"
+        save_path, _ = QFileDialog.getSaveFileName(
+            None,
+            "Save axon measurements CSV",
+            default_name,
+            "CSV files (*.csv)",
+        )
+        if save_path:
+            df.to_csv(save_path, index=False)
+
+    viewer.status = f"Myelin Quantifier: detected {len(df)} axons (filtered)."

napari_myelin_quantifier/_writer.py

@@ -0,0 +1,66 @@
+"""
+This module is an example of a barebones writer plugin for napari.
+
+It implements the Writer specification.
+see: https://napari.org/stable/plugins/building_a_plugin/guides.html#writers
+
+Replace code below according to your needs.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, Union
+
+if TYPE_CHECKING:
+    DataType = Union[Any, Sequence[Any]]
+    FullLayerData = tuple[DataType, dict, str]
+
+
+def write_single_image(path: str, data: Any, meta: dict) -> list[str]:
+    """Writes a single image layer.
+
+    Parameters
+    ----------
+    path : str
+        A string path indicating where to save the image file.
+    data : The layer data
+        The `.data` attribute from the napari layer.
+    meta : dict
+        A dictionary containing all other attributes from the napari layer
+        (excluding the `.data` layer attribute).
+
+    Returns
+    -------
+    [path] : A list containing the string path to the saved file.
+    """
+
+    # implement your writer logic here ...
+
+    # return path to any file(s) that were successfully written
+    return [path]
+
+
+def write_multiple(path: str, data: list[FullLayerData]) -> list[str]:
+    """Writes multiple layers of different types.
+
+    Parameters
+    ----------
+    path : str
+        A string path indicating where to save the data file(s).
+    data : A list of layer tuples.
+        Tuples contain three elements: (data, meta, layer_type)
+        `data` is the layer data
+        `meta` is a dictionary containing all other metadata attributes
+        from the napari layer (excluding the `.data` layer attribute).
+        `layer_type` is a string, eg: "image", "labels", "surface", etc.
+
+    Returns
+    -------
+    [path] : A list containing (potentially multiple) string paths to the saved file(s).
+    """
+
+    # implement your writer logic here ...
+
+    # return path to any file(s) that were successfully written
+    return [path]

napari_myelin_quantifier/napari.yaml

@@ -0,0 +1,18 @@
+name: napari-myelin-quantifier
+display_name: Myelin Quantifier
+visibility: public
+
+contributions:
+  commands:
+    - id: napari-myelin-quantifier.myelin_quantifier_widget
+      python_name: napari_myelin_quantifier._widget:myelin_quantifier_widget
+      title: Myelin Quantifier (Axon Counter)
+
+  widgets:
+    - command: napari-myelin-quantifier.myelin_quantifier_widget
+      display_name: Myelin Quantifier
+
+  menus:
+    napari/plugins:
+      - command: napari-myelin-quantifier.myelin_quantifier_widget
+        when: always

napari_myelin_quantifier-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: napari-myelin-quantifier
+Version: 0.1.0
+Summary: Quantify myelinated axons with label tracking
+Author: Napari User
+Author-email: wulinteo.usa2@gmail.com
+License: 
+        The MIT License (MIT)
+        
+        Copyright (c) 2026 Napari User
+        
+        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.
+        
+Project-URL: Bug Tracker, https://github.com/wulinteousa2-hash/napari-myelin-quantifier/issues
+Project-URL: Documentation, https://github.com/wulinteousa2-hash/napari-myelin-quantifier#README.md
+Project-URL: Source Code, https://github.com/wulinteousa2-hash/napari-myelin-quantifier
+Project-URL: User Support, https://github.com/wulinteousa2-hash/napari-myelin-quantifier/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: magicgui
+Requires-Dist: qtpy
+Requires-Dist: scikit-image
+Provides-Extra: all
+Requires-Dist: napari[all]; extra == "all"
+Dynamic: license-file
+
+# napari-myelin-quantifier
+
+[![License MIT](https://img.shields.io/pypi/l/napari-myelin-quantifier.svg?color=green)](https://github.com/wulinteousa2-hash/napari-myelin-quantifier/raw/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/napari-myelin-quantifier.svg?color=green)](https://pypi.org/project/napari-myelin-quantifier)
+[![Python Version](https://img.shields.io/pypi/pyversions/napari-myelin-quantifier.svg?color=green)](https://python.org)
+[![tests](https://github.com/wulinteousa2-hash/napari-myelin-quantifier/workflows/tests/badge.svg)](https://github.com/wulinteousa2-hash/napari-myelin-quantifier/actions)
+[![codecov](https://codecov.io/gh/wulinteousa2-hash/napari-myelin-quantifier/branch/main/graph/badge.svg)](https://codecov.io/gh/wulinteousa2-hash/napari-myelin-quantifier)
+[![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/napari-myelin-quantifier)](https://napari-hub.org/plugins/napari-myelin-quantifier)
+[![npe2](https://img.shields.io/badge/plugin-npe2-blue?link=https://napari.org/stable/plugins/index.html)](https://napari.org/stable/plugins/index.html)
+[![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-purple.json)](https://github.com/copier-org/copier)
+
+Quantify myelinated axons with label tracking
+
+----------------------------------
+
+This [napari] plugin was generated with [copier] using the [napari-plugin-template] (None).
+
+<!--
+Don't miss the full getting started guide to set up your new package:
+https://github.com/napari/napari-plugin-template#getting-started
+
+and review the napari docs for plugin developers:
+https://napari.org/stable/plugins/index.html
+-->
+
+## Installation
+
+You can install `napari-myelin-quantifier` via [pip]:
+
+```
+pip install napari-myelin-quantifier
+```
+
+If napari is not already installed, you can install `napari-myelin-quantifier` with napari and Qt via:
+
+```
+pip install "napari-myelin-quantifier[all]"
+```
+
+
+To install latest development version :
+
+```
+pip install git+https://github.com/wulinteousa2-hash/napari-myelin-quantifier.git
+```
+
+
+
+## Contributing
+
+Contributions are very welcome. Tests can be run with [tox], please ensure
+the coverage at least stays the same before you submit a pull request.
+
+## License
+
+Distributed under the terms of the [MIT] license,
+"napari-myelin-quantifier" is free and open source software
+
+## Issues
+
+If you encounter any problems, please [file an issue] along with a detailed description.
+
+[napari]: https://github.com/napari/napari
+[copier]: https://copier.readthedocs.io/en/stable/
+[@napari]: https://github.com/napari
+[MIT]: http://opensource.org/licenses/MIT
+[BSD-3]: http://opensource.org/licenses/BSD-3-Clause
+[GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
+[GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
+[Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
+[Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
+[napari-plugin-template]: https://github.com/napari/napari-plugin-template
+
+[file an issue]: https://github.com/wulinteousa2-hash/napari-myelin-quantifier/issues
+
+[napari]: https://github.com/napari/napari
+[tox]: https://tox.readthedocs.io/en/latest/
+[pip]: https://pypi.org/project/pip/
+[PyPI]: https://pypi.org/

napari_myelin_quantifier-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+napari_myelin_quantifier/__init__.py,sha256=PQoEuuclJDku-ttiJPycAIgmCybSXFHRAGiKoNDj7nw,189
+napari_myelin_quantifier/_axon_quant.py,sha256=kL9bpR57MdpwNsQ9nMFaJVP4fKuvOb4xP-221BcTOlM,6430
+napari_myelin_quantifier/_reader.py,sha256=bAlIoUWx8N0IYF1InuqDUO1kL5N7L9r9jtMLm3eFlcY,3127
+napari_myelin_quantifier/_sample_data.py,sha256=uHTGOqeoHhn1g-P11jEIFi7DOFtud9cB9aDnIVDvEig,662
+napari_myelin_quantifier/_version.py,sha256=bauHj-EPGxrNjRoP5OYKhJo32mQBOMvEa2cW00W0jHk,738
+napari_myelin_quantifier/_widget.py,sha256=h84e_rmy8HmuAi3RbXIdYonGykcEl_yCN3TMdWoR5KY,4485
+napari_myelin_quantifier/_writer.py,sha256=R8DYqFtpA2TinwioQYcspMDDwqrZqkssATt6SwjDrVs,1958
+napari_myelin_quantifier/napari.yaml,sha256=B270m-3v0ffZinsgx08jy_Nu1IIS8CVPoCHmQMKUP6c,526
+napari_myelin_quantifier-0.1.0.dist-info/licenses/LICENSE,sha256=d1ACW9b17QHlefOPYOe_0-5E8vCJe80eRDPS-U5wkA8,1079
+napari_myelin_quantifier-0.1.0.dist-info/METADATA,sha256=iiOrHYmpaUwAEcHt6WoNSFFbdb7YV9u1iBa0C-AnSeQ,6203
+napari_myelin_quantifier-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+napari_myelin_quantifier-0.1.0.dist-info/entry_points.txt,sha256=QcAh7UGBW1p1HqQ6fSnZKzAjld9srLFZQZBLdhf7Ga8,82
+napari_myelin_quantifier-0.1.0.dist-info/top_level.txt,sha256=DfQ-A26y__Y-MqVsnToCv-BUMrAmc5y26dggT7SMruE,25
+napari_myelin_quantifier-0.1.0.dist-info/RECORD,,

napari_myelin_quantifier-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

napari_myelin_quantifier-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+napari-myelin-quantifier = napari_myelin_quantifier:napari.yaml

napari_myelin_quantifier-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2026 Napari User
+
+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.

napari_myelin_quantifier-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+napari_myelin_quantifier