swcgeom 0.17.1__py3-none-any.whl → 0.18.1__py3-none-any.whl

swcgeom/transforms/branch.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Transformation in branch."""
 
 from abc import ABC, abstractmethod
@@ -72,10 +87,61 @@ class BranchLinearResampler(_BranchResampler):
         r = np.interp(xvals, xp, xyzr[:, 3])
         return cast(npt.NDArray[np.float32], np.stack([x, y, z, r], axis=1))
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"n_nodes={self.n_nodes}"
 
 
+class BranchIsometricResampler(_BranchResampler):
+    def __init__(self, distance: float, *, adjust_last_gap: bool = True) -> None:
+        super().__init__()
+        self.distance = distance
+        self.adjust_last_gap = adjust_last_gap
+
+    def resample(self, xyzr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+        """Resampling by isometric interpolation, DO NOT keep original node.
+
+        Parameters
+        ----------
+        xyzr : np.ndarray[np.float32]
+            The array of shape (N, 4).
+
+        Returns
+        -------
+        new_xyzr : ~numpy.NDArray[float32]
+            An array of shape (n_nodes, 4).
+        """
+
+        # Compute the cumulative distances between consecutive points
+        diffs = np.diff(xyzr[:, :3], axis=0)
+        distances = np.sqrt((diffs**2).sum(axis=1))
+        cumulative_distances = np.concatenate([[0], np.cumsum(distances)])
+
+        total_length = cumulative_distances[-1]
+        n_nodes = int(np.ceil(total_length / self.distance)) + 1
+
+        # Determine the new distances
+        if self.adjust_last_gap and n_nodes > 1:
+            new_distances = np.linspace(0, total_length, n_nodes)
+        else:
+            new_distances = np.arange(0, total_length, self.distance)
+            # keep endpoint
+            new_distances = np.concatenate([new_distances, total_length])
+
+        # Interpolate the new points
+        new_xyzr = np.zeros((n_nodes, 4), dtype=np.float32)
+        new_xyzr[:, :3] = np.array(
+            [
+                np.interp(new_distances, cumulative_distances, xyzr[:, i])
+                for i in range(3)
+            ]
+        ).T
+        new_xyzr[:, 3] = np.interp(new_distances, cumulative_distances, xyzr[:, 3])
+        return new_xyzr
+
+    def extra_repr(self) -> str:
+        return f"distance={self.distance},adjust_last_gap={self.adjust_last_gap}"
+
+
 class BranchConvSmoother(Transform[Branch, Branch[DictSWC]]):
     r"""Smooth the branch by sliding window."""
 
@@ -88,24 +154,24 @@ class BranchConvSmoother(Transform[Branch, Branch[DictSWC]]):
         """
         super().__init__()
         self.n_nodes = n_nodes
-        self.kernal = np.ones(n_nodes)
+        self.kernel = np.ones(n_nodes)
 
     def __call__(self, x: Branch) -> Branch[DictSWC]:
         x = x.detach()
-        c = signal.convolve(np.ones(x.number_of_nodes()), self.kernal, mode="same")
+        c = signal.convolve(np.ones(x.number_of_nodes()), self.kernel, mode="same")
         for k in ["x", "y", "z"]:
             v = x.get_ndata(k)
-            s = signal.convolve(v, self.kernal, mode="same")
+            s = signal.convolve(v, self.kernel, mode="same")
             x.attach.ndata[k][1:-1] = (s / c)[1:-1]
 
         return x
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"n_nodes={self.n_nodes}"
 
 
 class BranchStandardizer(Transform[Branch, Branch[DictSWC]]):
-    r"""Standarize branch.
+    r"""Standardize branch.
 
     Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up at
     y, and scale max radius to 1.
@@ -123,7 +189,7 @@ class BranchStandardizer(Transform[Branch, Branch[DictSWC]]):
 
     @staticmethod
     def get_matrix(xyz: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
-        r"""Get standarize transformation matrix.
+        r"""Get standardize transformation matrix.
 
         Standardized branch starts at (0, 0, 0), ends at (1, 0, 0), up
         at y.
@@ -136,7 +202,7 @@ class BranchStandardizer(Transform[Branch, Branch[DictSWC]]):
         Returns
         -------
         T : np.ndarray[np.float32]
-            An homogeneous transfomation matrix of shape (4, 4).
+            An homogeneous transformation matrix of shape (4, 4).
         """
 
         assert (

swcgeom/transforms/branch_tree.py

@@ -0,0 +1,82 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
+from typing import Iterable
+
+import numpy as np
+
+from swcgeom.core import Branch, BranchTree, Node, Tree
+from swcgeom.transforms.base import Transform
+
+__all__ = ["BranchTreeAssembler"]
+
+
+class BranchTreeAssembler(Transform[BranchTree, Tree]):
+    EPS = 1e-6
+
+    def __call__(self, x: BranchTree) -> Tree:
+        nodes = [x.soma().detach()]
+        stack = [(x.soma(), 0)]  # n_orig, id_new
+        while len(stack):
+            n_orig, pid_new = stack.pop()
+            children = n_orig.children()
+
+            for br, c in self.pair(x.branches.get(n_orig.id, []), children):
+                s = 1 if np.linalg.norm(br[0].xyz() - n_orig.xyz()) < self.EPS else 0
+                e = -2 if np.linalg.norm(br[-1].xyz() - c.xyz()) < self.EPS else -1
+
+                br_nodes = [n.detach() for n in br[s:e]] + [c.detach()]
+                for i, n in enumerate(br_nodes):
+                    # reindex
+                    n.id = len(nodes) + i
+                    n.pid = len(nodes) + i - 1
+
+                br_nodes[0].pid = pid_new
+                nodes.extend(br_nodes)
+                stack.append((c, br_nodes[-1].id))
+
+        return Tree(
+            len(nodes),
+            source=x.source,
+            comments=x.comments,
+            names=x.names,
+            **{
+                k: np.array([n.__getattribute__(k) for n in nodes])
+                for k in x.names.cols()
+            },
+        )
+
+    def pair(
+        self, branches: list[Branch], endpoints: list[Node]
+    ) -> Iterable[tuple[Branch, Node]]:
+        assert len(branches) == len(endpoints)
+        xyz1 = [br[-1].xyz() for br in branches]
+        xyz2 = [n.xyz() for n in endpoints]
+        v = np.reshape(xyz1, (-1, 1, 3)) - np.reshape(xyz2, (1, -1, 3))
+        dis = np.linalg.norm(v, axis=-1)
+
+        # greedy algorithm
+        pairs = []
+        for _ in range(len(branches)):
+            # find minimal
+            min_idx = np.argmin(dis)
+            min_branch_idx, min_endpoint_idx = np.unravel_index(min_idx, dis.shape)
+            pairs.append((branches[min_branch_idx], endpoints[min_endpoint_idx]))
+
+            # remove current node
+            dis[min_branch_idx, :] = np.inf
+            dis[:, min_endpoint_idx] = np.inf
+
+        return pairs

swcgeom/transforms/geometry.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """SWC geometry operations."""
 
 import warnings
@@ -72,7 +87,7 @@ class RadiusReseter(Generic[T], Transform[T, T]):
         new_tree.ndata[new_tree.names.r] = r
         return new_tree
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"r={self.r:.4f}"
 
 
@@ -141,7 +156,7 @@ class Translate(Generic[T], AffineTransform[T]):
         super().__init__(translate3d(tx, ty, tz), **kwargs)
         self.tx, self.ty, self.tz = tx, ty, tz
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"tx={self.tx:.4f}, ty={self.ty:.4f}, tz={self.tz:.4f}"
 
     @classmethod
@@ -194,8 +209,8 @@ class Rotate(Generic[T], AffineTransform[T]):
         self.theta = theta
         self.center = center
 
-    def extra_repr(self):
-        return f"n={self.n}, theta={self.theta:.4f}, center={self.center}"  # TODO: imporve format of n
+    def extra_repr(self) -> str:
+        return f"n={self.n}, theta={self.theta:.4f}, center={self.center}"  # TODO: improve format of n
 
     @classmethod
     def transform(
@@ -216,7 +231,7 @@ class RotateX(Generic[T], AffineTransform[T]):
         super().__init__(rotate3d_x(theta), center=center, **kwargs)
         self.theta = theta
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"center={self.center}, theta={self.theta:.4f}"
 
     @classmethod
@@ -232,7 +247,7 @@ class RotateY(Generic[T], AffineTransform[T]):
         self.theta = theta
         self.center = center
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"theta={self.theta:.4f}, center={self.center}"
 
     @classmethod
@@ -248,7 +263,7 @@ class RotateZ(Generic[T], AffineTransform[T]):
         self.theta = theta
         self.center = center
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"theta={self.theta:.4f}, center={self.center}"
 
     @classmethod

swcgeom/transforms/image_preprocess.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Image stack pre-processing."""
 
 import numpy as np

swcgeom/transforms/image_stack.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Create image stack from morphology.
 
 Notes
@@ -27,6 +42,7 @@ from sdflit import (
     SDFObject,
 )
 from tqdm import tqdm
+from typing_extensions import deprecated
 
 from swcgeom.core import Population, Tree
 from swcgeom.transforms.base import Transform
@@ -63,9 +79,9 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
         ONLY works for small image stacks, use :meth`transform_and_save`
         for big image stack.
         """
-        return np.stack(list(self.transfrom(x, verbose=False)), axis=0)
+        return np.stack(list(self.transform(x, verbose=False)), axis=0)
 
-    def transfrom(
+    def transform(
         self,
         x: Tree,
         verbose: bool = True,
@@ -102,10 +118,20 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
             frame = (255 * voxel[..., 0, 0]).astype(np.uint8)
             yield frame
 
+    @deprecated("Use transform instead")
+    def transfrom(
+        self,
+        x: Tree,
+        verbose: bool = True,
+        *,
+        ranges: Optional[tuple[npt.ArrayLike, npt.ArrayLike]] = None,
+    ) -> Iterable[npt.NDArray[np.uint8]]:
+        return self.transform(x, verbose, ranges=ranges)
+
     def transform_and_save(
         self, fname: str, x: Tree, verbose: bool = True, **kwargs
     ) -> None:
-        self.save_tif(fname, self.transfrom(x, verbose=verbose, **kwargs))
+        self.save_tif(fname, self.transform(x, verbose=verbose, **kwargs))
 
     def transform_population(
         self, population: Population | str, verbose: bool = True
@@ -125,7 +151,7 @@ class ToImageStack(Transform[Tree, npt.NDArray[np.uint8]]):
             if not os.path.isfile(tif):
                 self.transform_and_save(tif, tree, verbose=False)
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         res = ",".join(f"{a:.4f}" for a in self.resolution)
         return f"resolution=({res})"
 

swcgeom/transforms/images.py

@@ -1,9 +1,23 @@
-"""Image stack related transform."""
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
 
-import warnings
+"""Image stack related transform."""
 
 import numpy as np
 import numpy.typing as npt
+from typing_extensions import deprecated
 
 from swcgeom.transforms.base import Identity, Transform
 
@@ -45,6 +59,7 @@ class ImagesCenterCrop(Transform[NDArrayf32, NDArrayf32]):
         return f"shape_out=({','.join(str(a) for a in self.shape_out)})"
 
 
+@deprecated("use `ImagesCenterCrop` instead", stacklevel=2)
 class Center(ImagesCenterCrop):
     """Get image stack center.
 
@@ -52,14 +67,6 @@ class Center(ImagesCenterCrop):
         Use :class:`ImagesCenterCrop` instead.
     """
 
-    def __init__(self, shape_out: int | tuple[int, int, int]):
-        warnings.warn(
-            "`Center` is deprecated, use `ImagesCenterCrop` instead",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        super().__init__(shape_out)
-
 
 class ImagesScale(Transform[NDArrayf32, NDArrayf32]):
     def __init__(self, scaler: float) -> None:

swcgeom/transforms/mst.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Minimum spanning tree."""
 
 import warnings

swcgeom/transforms/neurolucida_asc.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Neurolucida related transformation."""
 
 import os
@@ -421,7 +436,7 @@ class Lexer:
         return self
 
     def __next__(self) -> Token:
-        match (word := self._read_word()):
+        match word := self._read_word():
             case "":
                 raise StopIteration
 

swcgeom/transforms/path.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Transformation in path."""
 
 from swcgeom.core import Path, Tree, redirect_tree

swcgeom/transforms/population.py

@@ -1,3 +1,18 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Transformation in population."""
 
 from swcgeom.core import Population, Tree

swcgeom/transforms/tree.py

@@ -1,15 +1,31 @@
+# Copyright 2022-2025 Zexin Yuan
+#
+# 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.
+
+
 """Transformation in tree."""
 
-import warnings
 from collections.abc import Callable
 from typing import Optional
 
 import numpy as np
+from typing_extensions import deprecated
 
-from swcgeom.core import BranchTree, DictSWC, Path, Tree, cut_tree, to_subtree
+from swcgeom.core import Branch, BranchTree, DictSWC, Path, Tree, cut_tree, to_subtree
 from swcgeom.core.swc_utils import SWCTypes, get_types
 from swcgeom.transforms.base import Transform
-from swcgeom.transforms.branch import BranchConvSmoother
+from swcgeom.transforms.branch import BranchConvSmoother, BranchIsometricResampler
+from swcgeom.transforms.branch_tree import BranchTreeAssembler
 from swcgeom.transforms.geometry import Normalizer
 
 __all__ = [
@@ -20,8 +36,9 @@ __all__ = [
     "CutByType",
     "CutAxonTree",
     "CutDendriteTree",
-    "CutByBifurcationOrder",
+    "CutByFurcationOrder",
     "CutShortTipBranch",
+    "IsometricResampler",
 ]
 
 
@@ -65,10 +82,11 @@ class TreeSmoother(Transform[Tree, Tree]):  # pylint: disable=missing-class-docs
 
         return x
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"n_nodes={self.n_nodes}"
 
 
+@deprecated("Use `Normalizer` instead")
 class TreeNormalizer(Normalizer[Tree]):
     """Noramlize coordinates and radius to 0-1.
 
@@ -76,15 +94,6 @@ class TreeNormalizer(Normalizer[Tree]):
         Use :cls:`Normalizer` instead.
     """
 
-    def __init__(self, *args, **kwargs) -> None:
-        warnings.warn(
-            "`TreeNormalizer` has been replaced by `Normalizer` since "
-            "v0.6.0 beacuse it applies more widely, and this will be "
-            "removed in next version",
-            DeprecationWarning,
-        )
-        super().__init__(*args, **kwargs)
-
 
 class CutByType(Transform[Tree, Tree]):
     """Cut tree by type.
@@ -112,7 +121,7 @@ class CutByType(Transform[Tree, Tree]):
         y = to_subtree(x, removals)
         return y
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"type={self.type}"
 
 
@@ -132,28 +141,48 @@ class CutDendriteTree(CutByType):
         super().__init__(type=types.basal_dendrite)  # TODO: apical dendrite
 
 
-class CutByBifurcationOrder(Transform[Tree, Tree]):
-    """Cut tree by bifurcation order."""
+class CutByFurcationOrder(Transform[Tree, Tree]):
+    """Cut tree by furcation order."""
 
-    max_bifurcation_order: int
+    max_furcation_order: int
 
     def __init__(self, max_bifurcation_order: int) -> None:
-        self.max_bifurcation_order = max_bifurcation_order
+        self.max_furcation_order = max_bifurcation_order
 
     def __call__(self, x: Tree) -> Tree:
         return cut_tree(x, enter=self._enter)
 
     def __repr__(self) -> str:
-        return f"CutByBifurcationOrder-{self.max_bifurcation_order}"
+        return f"CutByBifurcationOrder-{self.max_furcation_order}"
 
     def _enter(self, n: Tree.Node, parent_level: int | None) -> tuple[int, bool]:
         if parent_level is None:
             level = 0
-        elif n.is_bifurcation():
+        elif n.is_furcation():
             level = parent_level + 1
         else:
             level = parent_level
-        return (level, level >= self.max_bifurcation_order)
+        return (level, level >= self.max_furcation_order)
+
+
+@deprecated("Use CutByFurcationOrder instead")
+class CutByBifurcationOrder(CutByFurcationOrder):
+    """Cut tree by bifurcation order.
+
+    Notes
+    -----
+    Deprecated due to the wrong spelling of furcation. For now, it
+    is just an alias of `CutByFurcationOrder` and raise a warning. It
+    will be change to raise an error in the future.
+    """
+
+    max_furcation_order: int
+
+    def __init__(self, max_bifurcation_order: int) -> None:
+        super().__init__(max_bifurcation_order)
+
+    def __repr__(self) -> str:
+        return f"CutByBifurcationOrder-{self.max_furcation_order}"
 
 
 class CutShortTipBranch(Transform[Tree, Tree]):
@@ -183,7 +212,7 @@ class CutShortTipBranch(Transform[Tree, Tree]):
         self.callbacks.pop()
         return to_subtree(x, removals)
 
-    def extra_repr(self):
+    def extra_repr(self) -> str:
         return f"threshold={self.thre}"
 
     def _leave(
@@ -215,3 +244,27 @@ class CutShortTipBranch(Transform[Tree, Tree]):
                 cb(br)
 
         return None
+
+
+class Resampler(Transform[Tree, Tree]):
+    def __init__(self, branch_resampler: Transform[Branch, Branch]) -> None:
+        super().__init__()
+        self.resampler = branch_resampler
+        self.assembler = BranchTreeAssembler()
+
+    def __call__(self, x: Tree) -> Tree:
+        t = BranchTree.from_tree(x)
+        t.branches = {
+            k: [self.resampler(br) for br in brs] for k, brs in t.branches.items()
+        }
+        return self.assembler(t)
+
+
+class IsometricResampler(Resampler):
+    def __init__(
+        self, distance: float, *, adjust_last_gap: bool = True, **kwargs
+    ) -> None:
+        branch_resampler = BranchIsometricResampler(
+            distance, adjust_last_gap=adjust_last_gap, **kwargs
+        )
+        super().__init__(branch_resampler)