swcgeom 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

swcgeom/core/tree.py

@@ -20,15 +20,14 @@ from typing import (
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
-from typing_extensions import Self
 
 from swcgeom.core.branch import Branch
+from swcgeom.core.compartment import Compartment, Compartments
 from swcgeom.core.node import Node
 from swcgeom.core.path import Path
-from swcgeom.core.segment import Segment, Segments
 from swcgeom.core.swc import DictSWC, eswc_cols
 from swcgeom.core.swc_utils import SWCNames, get_names, read_swc, traverse
-from swcgeom.core.tree_utils_impl import get_subtree_impl
+from swcgeom.core.tree_utils_impl import Mapping, get_subtree_impl
 from swcgeom.utils import PathOrIO, padding1d
 
 __all__ = ["Tree"]
@@ -49,15 +48,6 @@ class Tree(DictSWC):
             children = self.attach.id()[self.attach.pid() == self.id]
             return [Tree.Node(self.attach, idx) for idx in children]
 
-        def get_branch(self) -> "Tree.Branch":
-            warnings.warn(
-                "`Tree.Node.get_branch` has been renamed to "
-                "`Tree.Node.branch` since v0.3.1 and will be removed "
-                "in next version",
-                DeprecationWarning,
-            )
-            return self.branch()
-
         def branch(self) -> "Tree.Branch":
             ns: List["Tree.Node"] = [self]
             while not ns[-1].is_bifurcation() and (p := ns[-1].parent()) is not None:
@@ -73,9 +63,18 @@ class Tree(DictSWC):
             """The end-to-end straight-line distance to soma."""
             return self.distance(self.attach.soma())
 
-        def subtree(self) -> "Tree":
-            """Get subtree from node."""
-            n_nodes, ndata, source, names = get_subtree_impl(self.attach, self.id)
+        def subtree(self, *, out_mapping: Optional[Mapping] = None) -> "Tree":
+            """Get subtree from node.
+
+            Parameters
+            ----------
+            out_mapping : List of int or Dict[int, int], optional
+                Map from new id to old id.
+            """
+
+            n_nodes, ndata, source, names = get_subtree_impl(
+                self.attach, self.id, out_mapping=out_mapping
+            )
             return Tree(n_nodes, **ndata, source=source, names=names)
 
         def is_root(self) -> bool:
@@ -107,9 +106,11 @@ class Tree(DictSWC):
         # TODO: should returns `Tree.Node`
         """Neural path."""
 
-    class Segment(Segment["Tree"]):
+    class Compartment(Compartment["Tree"]):
         # TODO: should returns `Tree.Node`
-        """Neural segment."""
+        """Neural compartment."""
+
+    Segment = Compartment  # Alias
 
     class Branch(Branch["Tree"]):
         # TODO: should returns `Tree.Node`
@@ -119,33 +120,33 @@ class Tree(DictSWC):
         self,
         n_nodes: int,
         *,
-        # pylint: disable-next=redefined-builtin
-        id: Optional[npt.NDArray[np.int32]] = None,
-        # pylint: disable-next=redefined-builtin
-        type: Optional[npt.NDArray[np.int32]] = None,
-        x: Optional[npt.NDArray[np.float32]] = None,
-        y: Optional[npt.NDArray[np.float32]] = None,
-        z: Optional[npt.NDArray[np.float32]] = None,
-        r: Optional[npt.NDArray[np.float32]] = None,
-        pid: Optional[npt.NDArray[np.int32]] = None,
         source: str = "",
         comments: Optional[Iterable[str]] = None,
         names: Optional[SWCNames] = None,
         **kwargs: npt.NDArray,
     ) -> None:
         names = get_names(names)
-        id = np.arange(0, n_nodes, step=1, dtype=np.int32) if id is None else id
-        pid = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32) if pid is None else pid
+
+        if names.id not in kwargs:
+            kwargs[names.id] = np.arange(0, n_nodes, step=1, dtype=np.int32)
+
+        if names.pid not in kwargs:
+            kwargs[names.pid] = np.arange(-1, n_nodes - 1, step=1, dtype=np.int32)
 
         ndata = {
-            names.id: padding1d(n_nodes, id, dtype=np.int32),
-            names.type: padding1d(n_nodes, type, dtype=np.int32),
-            names.x: padding1d(n_nodes, x),
-            names.y: padding1d(n_nodes, y),
-            names.z: padding1d(n_nodes, z),
-            names.r: padding1d(n_nodes, r, padding_value=1),
-            names.pid: padding1d(n_nodes, pid, dtype=np.int32),
+            names.id: padding1d(n_nodes, kwargs.pop(names.id, None), dtype=np.int32),
+            names.type: padding1d(
+                n_nodes, kwargs.pop(names.type, None), dtype=np.int32
+            ),
+            names.x: padding1d(n_nodes, kwargs.pop(names.x, None), dtype=np.float32),
+            names.y: padding1d(n_nodes, kwargs.pop(names.y, None), dtype=np.float32),
+            names.z: padding1d(n_nodes, kwargs.pop(names.z, None), dtype=np.float32),
+            names.r: padding1d(
+                n_nodes, kwargs.pop(names.r, None), dtype=np.float32, padding_value=1
+            ),
+            names.pid: padding1d(n_nodes, kwargs.pop(names.pid, None), dtype=np.int32),
         }
+        # ? padding other columns
         super().__init__(
             **ndata, **kwargs, source=source, comments=comments, names=names
         )
@@ -214,13 +215,16 @@ class Tree(DictSWC):
         tip_ids = np.setdiff1d(self.id(), self.pid(), assume_unique=True)
         return [self.node(i) for i in tip_ids]
 
-    def get_segments(self) -> Segments[Segment]:
-        return Segments(self.Segment(self, n.pid, n.id) for n in self[1:])
+    def get_compartments(self) -> Compartments[Compartment]:
+        return Compartments(self.Compartment(self, n.pid, n.id) for n in self[1:])
 
-    def get_branches(self) -> List[Branch]:
-        Info = Tuple[List[Tree.Branch], List[int]]
+    def get_segments(self) -> Compartments[Compartment]:  # Alias
+        return self.get_compartments()
 
-        def collect_branches(node: "Tree.Node", pre: List[Info]) -> Info:
+    def get_branches(self) -> List[Branch]:
+        def collect_branches(
+            node: "Tree.Node", pre: List[Tuple[List[Tree.Branch], List[int]]]
+        ) -> Tuple[List[Tree.Branch], List[int]]:
             if len(pre) == 1:
                 branches, child = pre[0]
                 child.append(node.id)
@@ -243,7 +247,6 @@ class Tree(DictSWC):
     def get_paths(self) -> List[Path]:
         """Get all path from soma to tips."""
         path_dic: Dict[int, List[int]] = {}
-        Paths = List[List[int]]
 
         def assign_path(n: Tree.Node, pre_path: List[int] | None) -> List[int]:
             path = [] if pre_path is None else pre_path.copy()
@@ -251,7 +254,9 @@ class Tree(DictSWC):
             path_dic[n.id] = path
             return path
 
-        def collect_path(n: Tree.Node, children: List[Paths]) -> Paths:
+        def collect_path(
+            n: Tree.Node, children: List[List[List[int]]]
+        ) -> List[List[int]]:
             if len(children) == 0:
                 return [path_dic[n.id]]
 
@@ -260,11 +265,11 @@ class Tree(DictSWC):
         paths = self.traverse(enter=assign_path, leave=collect_path)
         return [self.Path(self, idx) for idx in paths]
 
-    def get_neurites(self, type_check: bool = True) -> Iterable[Self]:
+    def get_neurites(self, type_check: bool = True) -> Iterable["Tree"]:
         """Get neurites from soma."""
         return (n.subtree() for n in self.soma(type_check).children())
 
-    def get_dendrites(self, type_check: bool = True) -> Iterable[Self]:
+    def get_dendrites(self, type_check: bool = True) -> Iterable["Tree"]:
         """Get dendrites."""
         types = [self.types.apical_dendrite, self.types.basal_dendrite]
         children = self.soma(type_check).children()
@@ -312,15 +317,14 @@ class Tree(DictSWC):
         """Get length of tree."""
         return sum(s.length() for s in self.get_segments())
 
-    @classmethod
+    @staticmethod
     def from_data_frame(
-        cls,
         df: pd.DataFrame,
         source: str = "",
         *,
         comments: Optional[Iterable[str]] = None,
         names: Optional[SWCNames] = None,
-    ) -> Self:
+    ) -> "Tree":
         """Read neuron tree from data frame."""
         names = get_names(names)
         tree = Tree(
@@ -333,7 +337,7 @@ class Tree(DictSWC):
         return tree
 
     @classmethod
-    def from_swc(cls, swc_file: PathOrIO, **kwargs) -> Self:
+    def from_swc(cls, swc_file: PathOrIO, **kwargs) -> "Tree":
         """Read neuron tree from swc file.
 
         See Also
@@ -352,7 +356,7 @@ class Tree(DictSWC):
     @classmethod
     def from_eswc(
         cls, swc_file: str, extra_cols: Optional[List[str]] = None, **kwargs
-    ) -> Self:
+    ) -> "Tree":
         """Read neuron tree from eswc file.
 
         See Also

swcgeom/core/tree_utils.py

@@ -17,7 +17,7 @@ from swcgeom.core.swc_utils import (
     to_sub_topology,
 )
 from swcgeom.core.tree import Tree
-from swcgeom.core.tree_utils_impl import get_subtree_impl, to_subtree_impl
+from swcgeom.core.tree_utils_impl import Mapping, get_subtree_impl, to_subtree_impl
 
 __all__ = [
     "sort_tree",
@@ -101,11 +101,15 @@ def to_sub_tree(swc_like: SWCLike, sub: Topology) -> Tuple[Tree, Dict[int, int]]
     but if the node you remove is not a leaf node, you need to use
     `propagate_remove` to remove all children.
 
+    .. deprecated:: 0.6.0
+        Use :meth:`to_subtree` instead.
+
     Returns
     -------
     tree : Tree
     id_map : Dict[int, int]
     """
+
     warnings.warn(
         "`to_sub_tree` will be removed in v0.6.0, it is replaced by "
         "`to_subtree` beacuse it is easy to use, and this will be "
@@ -128,7 +132,12 @@ def to_sub_tree(swc_like: SWCLike, sub: Topology) -> Tuple[Tree, Dict[int, int]]
     return subtree, id_map
 
 
-def to_subtree(swc_like: SWCLike, removals: Iterable[int]) -> Tree:
+def to_subtree(
+    swc_like: SWCLike,
+    removals: Iterable[int],
+    *,
+    out_mapping: Optional[Mapping] = None,
+) -> Tree:
     """Create subtree from origin tree.
 
     Parameters
@@ -136,17 +145,24 @@ def to_subtree(swc_like: SWCLike, removals: Iterable[int]) -> Tree:
     swc_like : SWCLike
     removals : List of int
         A list of id of nodes to be removed.
+    out_mapping: List of int or Dict[int, int], optional
+        Map new id to old id.
     """
+
     new_ids = swc_like.id().copy()
     for i in removals:
         new_ids[i] = REMOVAL
 
     sub = propagate_removal((new_ids, swc_like.pid()))
-    n_nodes, ndata, source, names = to_subtree_impl(swc_like, sub)
+    n_nodes, ndata, source, names = to_subtree_impl(
+        swc_like, sub, out_mapping=out_mapping
+    )
     return Tree(n_nodes, **ndata, source=source, names=names)
 
 
-def get_subtree(swc_like: SWCLike, n: int) -> Tree:
+def get_subtree(
+    swc_like: SWCLike, n: int, *, out_mapping: Optional[Mapping] = None
+) -> Tree:
     """Get subtree rooted at n.
 
     Parameters
@@ -154,8 +170,13 @@ def get_subtree(swc_like: SWCLike, n: int) -> Tree:
     swc_like : SWCLike
     n : int
         Id of the root of the subtree.
+    out_mapping: List of int or Dict[int, int], optional
+        Map new id to old id.
     """
-    n_nodes, ndata, source, names = get_subtree_impl(swc_like, n)
+
+    n_nodes, ndata, source, names = get_subtree_impl(
+        swc_like, n, out_mapping=out_mapping
+    )
     return Tree(n_nodes, **ndata, source=source, names=names)
 
 
@@ -171,6 +192,7 @@ def redirect_tree(tree: Tree, new_root: int, sort: bool = True) -> Tree:
     sort : bool, default `True`
         If true, sort indices of nodes after redirect.
     """
+
     tree = tree.copy()
     path = [tree.node(new_root)]
     while (p := path[-1].parent()) is not None:

swcgeom/core/tree_utils_impl.py

@@ -5,7 +5,7 @@ Notes
 Do not import `Tree` and keep this file minimized.
 """
 
-from typing import Any, Dict, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 import numpy.typing as npt
@@ -15,10 +15,13 @@ from swcgeom.core.swc_utils import Topology, to_sub_topology, traverse
 
 __all__ = ["get_subtree_impl", "to_subtree_impl"]
 
+Mapping = Dict[int, int] | List[int]
 TreeArgs = Tuple[int, Dict[str, npt.NDArray[Any]], str, SWCNames]
 
 
-def get_subtree_impl(swc_like: SWCLike, n: int) -> TreeArgs:
+def get_subtree_impl(
+    swc_like: SWCLike, n: int, *, out_mapping: Optional[Mapping] = None
+) -> TreeArgs:
     ids = []
     topo = (swc_like.id(), swc_like.pid())
     traverse(topo, enter=lambda n, _: ids.append(n), root=n)
@@ -26,14 +29,27 @@ def get_subtree_impl(swc_like: SWCLike, n: int) -> TreeArgs:
     sub_ids = np.array(ids, dtype=np.int32)
     sub_pid = swc_like.pid()[sub_ids]
     sub_pid[0] = -1
-    return to_subtree_impl(swc_like, (sub_ids, sub_pid))
+    return to_subtree_impl(swc_like, (sub_ids, sub_pid), out_mapping=out_mapping)
 
 
-def to_subtree_impl(swc_like: SWCLike, sub: Topology) -> TreeArgs:
-    (new_id, new_pid), id_map = to_sub_topology(sub)
+def to_subtree_impl(
+    swc_like: SWCLike,
+    sub: Topology,
+    *,
+    out_mapping: Optional[Mapping] = None,
+) -> TreeArgs:
+    (new_id, new_pid), mapping = to_sub_topology(sub)
 
     n_nodes = new_id.shape[0]
-    ndata = {k: swc_like.get_ndata(k)[id_map].copy() for k in swc_like.keys()}
+    ndata = {k: swc_like.get_ndata(k)[mapping].copy() for k in swc_like.keys()}
     ndata.update(id=new_id, pid=new_pid)
 
+    if isinstance(out_mapping, list):
+        out_mapping.clear()
+        out_mapping.extend(mapping)
+    elif isinstance(out_mapping, dict):
+        out_mapping.clear()
+        for new_id, old_id in enumerate(mapping):
+            out_mapping[new_id] = old_id  # returning a dict may leads to bad perf
+
     return n_nodes, ndata, swc_like.source, swc_like.names

swcgeom/images/augmentation.py

@@ -1,4 +1,9 @@
-"""Play augment in image stack."""
+"""Play augment in image stack.
+
+Notes
+-----
+This is expremental code, and the API is subject to change.
+"""
 
 import random
 from typing import List, Literal, Optional

swcgeom/images/contrast.py

@@ -0,0 +1,107 @@
+"""The contrast of an image.
+
+Notes
+-----
+This is expremental code, and the API is subject to change.
+"""
+
+from typing import Optional, overload
+
+import numpy as np
+import numpy.typing as npt
+
+__all__ = ["contrast_std", "contrast_michelson", "contrast_rms", "contrast_weber"]
+
+Array3D = npt.NDArray[np.float32]
+
+
+@overload
+def contrast_std(image: Array3D) -> float:
+    """Get the std contrast of an image stack.
+
+    Parameters
+    ----------
+    imgs : ndarray
+
+    Returns
+    -------
+    contrast : float
+    """
+    ...
+
+
+@overload
+def contrast_std(image: Array3D, contrast: float) -> Array3D:
+    """Adjust the contrast of an image stack.
+
+    Parameters
+    ----------
+    imgs : ndarray
+    constrast : float
+        The contrast adjustment factor. 1.0 leaves the image unchanged.
+
+    Returns
+    -------
+    imgs : ndarray
+        The adjusted image.
+    """
+    ...
+
+
+def contrast_std(image: Array3D, contrast: Optional[float] = None):
+    if contrast is None:
+        return np.std(image).item()
+    else:
+        return np.clip(contrast * image, 0, 1)
+
+
+def contrast_michelson(image: Array3D) -> float:
+    """Get the Michelson contrast of an image stack.
+
+    Parameters
+    ----------
+    imgs : ndarray
+
+    Returns
+    -------
+    contrast : float
+    """
+
+    vmax = np.max(image)
+    vmin = np.min(image)
+    return ((vmax - vmin) / (vmax + vmin)).item()
+
+
+def contrast_rms(imgs: npt.NDArray[np.float32]) -> float:
+    """Get the RMS contrast of an image stack.
+
+    Parameters
+    ----------
+    imgs : ndarray
+
+    Returns
+    -------
+    contrast : float
+    """
+
+    return np.sqrt(np.mean(imgs**2)).item()
+
+
+def contrast_weber(imgs: Array3D, mask: npt.NDArray[np.bool_]) -> float:
+    """Get the Weber contrast of an image stack.
+
+    Parameters
+    ----------
+    imgs : ndarray
+    mask : ndarray of bool
+        The mask to segment the foreground and background. 1 for
+        foreground, 0 for background.
+
+    Returns
+    -------
+    contrast : float
+    """
+
+    l_foreground = np.mean(imgs, where=mask)
+    l_background = np.mean(imgs, where=np.logical_not(mask))
+    return ((l_foreground - l_background) / l_background).item()

swcgeom/images/folder.py

@@ -1,57 +1,64 @@
 """Image stack folder."""
 
+import math
 import os
 import re
-from abc import ABC, abstractmethod
-from typing import Callable, Generic, Iterable, List, Literal, Optional, Tuple, TypeVar
+import warnings
+from dataclasses import dataclass
+from typing import (
+    Callable,
+    Generic,
+    Iterable,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypeVar,
+    overload,
+)
 
 import numpy as np
 import numpy.typing as npt
+from tqdm import tqdm
 from typing_extensions import Self
 
-from swcgeom.images.io import read_imgs
+from swcgeom.images.io import ScalarType, read_imgs
 from swcgeom.transforms import Identity, Transform
 
-__all__ = [
-    "ImageStackFolder",
-    "LabeledImageStackFolder",
-    "PathImageStackFolder",
-]
+__all__ = ["ImageStackFolder", "LabeledImageStackFolder", "PathImageStackFolder"]
 
 T = TypeVar("T")
 
 
-class ImageStackFolderBase(Generic[T], ABC):
+class ImageStackFolderBase(Generic[ScalarType, T]):
     """Image stack folder base."""
 
     files: List[str]
-    transform: Transform[npt.NDArray[np.float32], T]
+    transform: Transform[npt.NDArray[ScalarType], T]
 
-    def __init__(
-        self,
-        files: Iterable[str],
-        *,
-        transform: Optional[Transform[npt.NDArray[np.float32], T]] = None,
-    ) -> None:
+    # fmt: off
+    @overload
+    def __init__(self, files: Iterable[str], *, dtype: None = ..., transform: Optional[Transform[npt.NDArray[np.float32], T]] = None) -> None: ...
+    @overload
+    def __init__(self, files: Iterable[str], *, dtype: ScalarType, transform: Optional[Transform[npt.NDArray[ScalarType], T]] = None) -> None: ...
+    # fmt: on
+
+    def __init__(self, files: Iterable[str], *, dtype=None, transform=None) -> None:
         super().__init__()
         self.files = list(files)
+        self.dtype = dtype or np.float32
         self.transform = transform or Identity()  # type: ignore
 
-    @abstractmethod
-    def __getitem__(self, key: str, /) -> T:
-        raise NotImplementedError()
-
     def __len__(self) -> int:
         return len(self.files)
 
     def _get(self, fname: str) -> T:
-        imgs = self.read_imgs(fname)
+        imgs = self._read(fname)
         imgs = self.transform(imgs)
         return imgs
 
-    @staticmethod
-    def read_imgs(fname: str) -> npt.NDArray[np.float32]:
-        return read_imgs(fname).get_full()
+    def _read(self, fname: str) -> npt.NDArray[ScalarType]:
+        return read_imgs(fname, dtype=self.dtype).get_full()  # type: ignore
 
     @staticmethod
     def scan(root: str, *, pattern: Optional[str] = None) -> List[str]:
@@ -63,13 +70,86 @@ class ImageStackFolderBase(Generic[T], ABC):
 
         return fs
 
+    @staticmethod
+    def read_imgs(fname: str) -> npt.NDArray[np.float32]:
+        """Read images.
+
+        .. deprecated:: 0.16.0
+            Use :meth:`~swcgeom.images.io.read_imgs(fname).get_full()` instead.
+        """
+
+        warnings.warn(
+            "`ImageStackFolderBase.read_imgs` serves as a "
+            "straightforward wrapper for `~swcgeom.images.io.read_imgs(fname).get_full()`. "
+            "However, as it is not utilized within our internal "
+            "processes, it is scheduled for removal in the "
+            "forthcoming version.",
+            DeprecationWarning,
+        )
+        return read_imgs(fname).get_full()
 
-class ImageStackFolder(Generic[T], ImageStackFolderBase[T]):
+
+@dataclass(frozen=True)
+class Statistics:
+    count: int = 0
+    minimum: float = math.nan
+    maximum: float = math.nan
+    mean: float = 0
+    variance: float = 0
+
+
+class ImageStackFolder(ImageStackFolderBase[ScalarType, T]):
     """Image stack folder."""
 
     def __getitem__(self, idx: int, /) -> T:
         return self._get(self.files[idx])
 
+    def stat(self, *, transform: bool = False, verbose: bool = False) -> Statistics:
+        """Statistics of folder.
+
+        Parameters
+        ----------
+        transform : bool, default to False
+            Apply transform to the images. If True, you need to make
+            sure the transformed data is a ndarray.
+        verbose : bool, optional
+
+        Notes
+        -----
+        We are asserting that the images are of the same shape.
+        """
+
+        vmin, vmax = math.inf, -math.inf
+        n, mean, M2 = 0, None, None
+
+        for idx in tqdm(range(len(self))) if verbose else range(len(self)):
+            imgs = self[idx] if transform else self._read(self.files[idx])
+
+            vmin = min(vmin, np.min(imgs))  # type: ignore
+            vmax = max(vmax, np.max(imgs))  # type: ignore
+            # Welford algorithm to calculate mean and variance
+            if mean is None:
+                mean = np.zeros_like(imgs)
+                M2 = np.zeros_like(imgs)
+
+            n += 1
+            delta = imgs - mean  # type: ignore
+            mean += delta / n
+            delta2 = imgs - mean
+            M2 += delta * delta2
+
+        if mean is None or M2 is None:  # n = 0
+            raise ValueError("empty folder")
+
+        variance = M2 / (n - 1) if n > 1 else np.zeros_like(mean)
+        return Statistics(
+            count=len(self),
+            maximum=vmax,
+            minimum=vmin,
+            mean=np.mean(mean).item(),
+            variance=np.mean(variance).item(),
+        )
+
     @classmethod
     def from_dir(cls, root: str, *, pattern: Optional[str] = None, **kwargs) -> Self:
         """
@@ -81,10 +161,11 @@ class ImageStackFolder(Generic[T], ImageStackFolderBase[T]):
         **kwargs
             Pass to `cls.__init__`
         """
+
         return cls(cls.scan(root, pattern=pattern), **kwargs)
 
 
-class LabeledImageStackFolder(Generic[T], ImageStackFolderBase[T]):
+class LabeledImageStackFolder(ImageStackFolderBase[ScalarType, T]):
     """Image stack folder with label."""
 
     labels: List[int]
@@ -93,8 +174,8 @@ class LabeledImageStackFolder(Generic[T], ImageStackFolderBase[T]):
         super().__init__(files, **kwargs)
         self.labels = list(labels)
 
-    def __getitem__(self, idx: int) -> Tuple[npt.NDArray[np.float32], int]:
-        return self.read_imgs(self.files[idx]), self.labels[idx]
+    def __getitem__(self, idx: int) -> Tuple[T, int]:
+        return self._get(self.files[idx]), self.labels[idx]
 
     @classmethod
     def from_dir(
@@ -115,7 +196,7 @@ class LabeledImageStackFolder(Generic[T], ImageStackFolderBase[T]):
         return cls(files, labels, **kwargs)
 
 
-class PathImageStackFolder(Generic[T], ImageStackFolder[T]):
+class PathImageStackFolder(ImageStackFolderBase[ScalarType, T]):
     """Image stack folder with relpath."""
 
     root: str
@@ -139,6 +220,7 @@ class PathImageStackFolder(Generic[T], ImageStackFolder[T]):
         **kwargs
             Pass to `cls.__init__`
         """
+
         return cls(cls.scan(root, pattern=pattern), root=root, **kwargs)