An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish.

Code ↔ Paper

1 match between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 1 match

[1] § Materials and methods › Generation of DNA constructs and transgenic lines ↔ navis/transforms/templates.py, lines 1025 to 1170 · score 0.53 · Janelia Research Campus, sequence · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 1,790 lines · 67 KB · GPL-3.0 · 1 match

# This script is part of navis (http://www.github.com/navis-org/navis).
# Copyright (C) 2018 Philipp Schlegel
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
"""Functions to work with templates."""
import functools
import os
import pathlib
import warnings
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcl
import networkx as nx
import seaborn as sns
import sparsecubes
import trimesh as tm
from matplotlib.lines import Line2D
from collections import namedtuple
from typing import List, Union, Optional
from typing_extensions import Literal
from .. import config, core, utils
from . import factory
from .base import TransformSequence, BaseTransform, AliasTransform, is_invertible
from .xfm_funcs import mirror, xform
# Catch some stupid warning about installing python-Levenshtein
with warnings.catch_warnings():
warnings.simplefilter("ignore")
import fuzzywuzzy as fw
import fuzzywuzzy.process
__all__ = ["xform_brain", "mirror_brain", "symmetrize_brain", "render_template"]
logger = config.get_logger(__name__)
# Defines entry the registry needs to register a transform
transform_reg = namedtuple(
"Transform",
["source", "target", "transform", "type", "invertible", "weight", "weight_inv"],
defaults=[None], # for weight_inv
)
# Check for environment variable pointing to registries
_OS_TRANSPATHS = os.environ.get("NAVIS_TRANSFORMS", "")
try:
_OS_TRANSPATHS = [i for i in _OS_TRANSPATHS.split(";") if len(i) > 0]
except BaseException:
logger.error("Error parsing the `NAVIS_TRANSFORMS` environment variable")
_OS_TRANSPATHS = []
def _deprecate_reciprocal(reciprocal, inverse_weight):
"""Map the old `reciprocal` argument onto `inverse_weight`."""
if reciprocal is None:
return inverse_weight
warnings.warn(
"`reciprocal` is deprecated and will be removed in a future version - "
"use `inverse_weight` instead. Note the default changed from 0.5 to 1: "
"navis no longer discounts inverse transforms across the board, because "
"each transform now says for itself how expensive it is to invert.",
DeprecationWarning,
stacklevel=3,
)
return reciprocal
def _pick_edge(G, n1, n2, prefer_forward: bool = True):
"""Pick which transform to use for the hop n1 -> n2.
Two templates can be connected by more than one registration - typically a
purpose-built registration for this direction alongside the inverse of its
counterpart, but sometimes several independent registrations.
Selection is by weight, and - as everywhere else - **lower weight wins**. That
is the same rule `nx.shortest_path` used to cost the route in the first place,
so the transform we hand back is the one the route was planned around.
On top of that, if `prefer_forward` is True (the default), a forward
registration beats the inverse of its counterpart *regardless of weight*: it is
the map its authors actually fitted for this direction. Weights still decide
among several forward registrations (or, if there is no forward edge, among
several inverse ones).
Why the preference is not simply expressed as a weight: `weight` is what
`shortest_path` minimises when choosing the path, and the two uses pull in
opposite directions. To stop an inverse edge dragging unrelated routes through
it you must weight it *up*; to stop it being picked over a forward edge you
must weight it *down*. No single number does both. So weight means one thing
only - what a hop costs - and forward-vs-inverse is decided here.
Parameters
----------
prefer_forward : bool
If False, pick purely by weight and let an inverse edge win
if it is cheaper. Use this if you have weighted your graph
deliberately and want it taken at face value.
"""
edges = []
i = 0
# Collect all edges between those two nodes
# - this is annoyingly complicated with MultiDiGraphs
while True:
try:
e = G.edges[(n1, n2, i)]
except KeyError:
break
edges.append(e)
i += 1
candidates = edges
if prefer_forward:
# (Edges added before `inverse` was tracked are treated as forward.)
forward = [e for e in edges if not e.get("inverse", False)]
candidates = forward if forward else edges
# Lower weight wins - same rule `shortest_path` used to pick the route.
return min(candidates, key=lambda e: e["weight"])["transform"]
class TemplateRegistry:
"""Tracks template brains, available transforms and produces bridging sequences.
Parameters
----------
scan_paths : bool
If True will scan paths on initialization.
"""
def __init__(self, scan_paths: bool = True):
# Paths to scan for transforms
self._transpaths = _OS_TRANSPATHS.copy()
# Transforms
self._transforms = []
# Template brains
self._templates = []
if scan_paths:
self.scan_paths()
def __contains__(self, other) -> bool:
"""Check if transform is in registry.
Parameters
----------
other : transform, filepath, tuple
Either a transform (e.g. CMTKtransform), a filepath (e.g.
to a .list file) or a tuple of `(source, target, transform)`
where `transform` can be a transform or a filepath.
"""
if isinstance(other, (tuple, list)):
return any([t == other for t in self.transforms])
else:
return other in [t.transform for t in self.transforms]
def __len__(self) -> int:
return len(self.transforms)
def __repr__(self):
return self.__str__()
def __str__(self):
return f"TemplateRegistry with {len(self)} transforms"
@property
def transpaths(self) -> list:
"""Paths searched for transforms.
Use `.scan_paths` to trigger a scan. Use `.register_path` to add
more path(s).
"""
return self._transpaths
@property
def templates(self) -> list:
"""Registered template (brains)."""
return self._templates
@property
def transforms(self) -> list:
"""Registered transforms (bridging + mirror)."""
return self._transforms
@property
def bridges(self) -> list:
"""Registered bridging transforms."""
return [t for t in self.transforms if t.type == "bridging"]
@property
def mirrors(self) -> list:
"""Registered mirror transforms."""
return [t for t in self.transforms if t.type == "mirror"]
def clear_caches(self):
"""Clear caches of all cached functions."""
self.bridging_graph.cache_clear()
self.shortest_bridging_seq.cache_clear()
def summary(self) -> pd.DataFrame:
"""Generate summary of available transforms."""
return pd.DataFrame(self.transforms)
def register_path(self, paths: str, trigger_scan: bool = True):
"""Register path(s) to scan for transforms.
Parameters
----------
paths : str | list thereof
Paths (or list thereof) to scans for transforms. This
is not permanent. For permanent additions set path(s)
via the `NAVIS_TRANSFORMS` environment variable.
trigger_scan : bool
If True, a re-scan of all paths will be triggered.
"""
paths = utils.make_iterable(paths)
for p in paths:
# Try not to duplicate paths
if p not in self.transpaths:
self._transpaths.append(p)
if trigger_scan:
self.scan_paths()
def register_templatebrain(self, template: "TemplateBrain", skip_existing=True):
"""Register a template brain.
This is used, for example, by navis.mirror_brain.
Parameters
----------
template : TemplateBrain
TemplateBrain to register.
skip_existing : bool
If True, will skip existing template brains.
"""
utils.eval_param(template, name="template", allowed_types=(TemplateBrain,))
if template not in self._templates or not skip_existing:
self._templates.append(template)
def register_transform(
self,
transform: BaseTransform,
source: str,
target: str,
transform_type: str,
skip_existing: bool = True,
weight: int = 1,
weight_inv: Optional[int] = None,
):
"""Register a transform.
Parameters
----------
transform : subclass of BaseTransform | TransformSequence
A transform (AffineTransform, CMTKtransform, etc.)
or a TransformSequence.
source : str
Source for forward transform.
target : str
Target for forward transform. Ignored for mirror
transforms.
transform_type : "bridging" | "mirror"
Type of transform.
skip_existing : bool
If True will skip if transform is already in registry.
weight : float
What this transform costs to traverse forwards.
**Lower weight = more likely to be used** - both when
choosing a route and when picking between several
registrations connecting the same two templates.
weight_inv : float, optional
What this transform costs to traverse *backwards*.
If not given, defaults to
`weight * transform.inverse_weight_factor` - i.e. the
transform says for itself how much dearer it is to
invert. That is 1 for anything whose inverse is stored
or exact (affine, H5, thin-plate spline), and more for
anything that has to solve for it numerically (CMTK,
and elastix especially).
Passing this explicitly overrides
`inverse_weight_factor` entirely - use it when you know
better than the default for a particular registration.
Note that weight decides which *route* is taken; it does
not, on its own, decide whether an inverse is used in
place of a purpose-built registration. That is
`prefer_forward` (see
`TemplateRegistry.find_bridging_path`), which is on by
default.
See Also
--------
register_transformfile
If you want to register a file instead of an
already constructed transform.
"""
assert transform_type in ("bridging", "mirror")
assert isinstance(transform, (BaseTransform, TransformSequence))
# Translate into edge
edge = transform_reg(
source=source,
target=target,
transform=transform,
type=transform_type,
invertible=is_invertible(transform),
weight=weight,
# Some transforms are dearer to traverse backwards than forwards -
# elastix in particular, where the inverse is an iterative numerical
# solve rather than a stored map. Those advertise an
# `inverse_weight_factor` to say so, and their inverse edges cost more.
# Note this only affects what a hop *costs*; a forward registration is
# preferred over an inverse one regardless (see `_pick_edge`).
weight_inv=(
weight_inv
if weight_inv is not None
else weight * getattr(transform, "inverse_weight_factor", 1)
),
)
# Don't add if already exists
if not skip_existing or edge not in self:
self.transforms.append(edge)
# Clear cached functions
self.clear_caches()
def register_transformfile(self, path: str, **kwargs):
"""Parse and register a transform file.
File/Directory name must follow the a `{TARGET}_{SOURCE}.{ext}`
convention (e.g. `JRC2013_FCWB.list`).
Parameters
----------
path : str
Path to transform.
**kwargs
Keyword arguments are passed to the constructor of the
Transform (e.g. CMTKtransform for `.list` directory).
See Also
--------
register_transform
If you want to register an already constructed transform
instead of a transform file that still needs to be
parsed.
"""
assert isinstance(path, (str, pathlib.Path))
path = pathlib.Path(path).expanduser()
if not path.is_dir() and not path.is_file():
raise ValueError(f'File/directory "{path}" does not exist')
# Parse properties
try:
if "mirror" in path.name or "imgflip" in path.name:
transform_type = "mirror"
source = path.name.split("_")[0]
target = None
else:
transform_type = "bridging"
target = path.name.split("_")[0]
source = path.name.split("_")[1].split(".")[0]
# Initialize the transform
transform = factory.factory_methods[path.suffix](path, **kwargs)
self.register_transform(
transform=transform,
source=source,
target=target,
transform_type=transform_type,
)
except BaseException as e:
logger.error(f"Error registering {path} as transform: {str(e)}")
def scan_paths(self, extra_paths: List[str] = None):
"""Scan registered paths for transforms and add to registry.
Will skip transforms that already exist in this registry.
Parameters
----------
extra_paths : list of str
Any Extra paths to search.
"""
search_paths = self.transpaths
if isinstance(extra_paths, str):
extra_paths = [i for i in extra_paths.split(";") if len(i) > 0]
search_paths = np.append(search_paths, extra_paths)
for path in search_paths:
path = pathlib.Path(path).expanduser()
# Skip if path does not exist
if not path.is_dir():
continue
# Go over the file extensions we can work with (.h5, .list, .json)
# These file extensions are registered in the
# `navis.transforms.factory` module
for ext in factory.factory_methods:
for hit in path.rglob(f"*{ext}"):
if hit.is_dir() or hit.is_file():
# Register this file
self.register_transformfile(hit)
# Clear cached functions
self.clear_caches()
@functools.lru_cache()
def bridging_graph(
self,
inverse_weight: Union[Literal[False], int, float] = 1,
reciprocal=None,
) -> nx.DiGraph:
"""Generate networkx Graph describing the bridging paths.
Parameters
----------
inverse_weight : bool | float
Whether to add inverse edges for transforms that can be
inverted, and what to charge for them.
`1` (default) trusts the weights already on the graph: an
inverse edge costs its transform's `weight_inv`, which by
default already accounts for how expensive that particular
transform is to invert (see `register_transform`).
Pass another number to scale every inverse edge by it - a
blunt, global "avoid going backwards" (> 1) or "don't mind
going backwards" (< 1) dial. Remember lower weight = more
likely to be used.
`False` drops inverse edges altogether.
reciprocal : bool | float
Deprecated alias for `inverse_weight`.
Returns
-------
networkx.MultiDiGraph
"""
inverse_weight = _deprecate_reciprocal(reciprocal, inverse_weight)
# Drop mirror transforms
bridge = [t for t in self.transforms if t.type == "bridging"]
# Note we re-check invertibility here rather than trusting the snapshot
# taken at registration time: for elastix transforms it depends on the
# transform backend, which the user can change at run time.
bridge_inv = [t for t in bridge if is_invertible(t.transform)]
# Generate graph
# Note we are using MultiDi graph here because we might
# have multiple edges between nodes. For example, there
# is a JFRC2013DS_JFRC2013 and a JFRC2013_JFRC2013DS
# bridging registration. If we include the inverse, there
# will be two edges connecting JFRC2013DS and JFRC2013 in
# both directions
G = nx.MultiDiGraph()
edges = [
(
t.source,
t.target,
{
"transform": t.transform,
"type": type(t.transform).__name__,
"weight": t.weight,
"inverse": False,
},
)
for t in bridge
]
if inverse_weight is not False:
# `True` means "as weighted" - i.e. the same as 1.
scale = 1 if inverse_weight is True else inverse_weight
edges += [
(
t.target,
t.source,
{
"transform": -t.transform, # note inverse transform!
"type": type(t.transform).__name__,
"weight": t.weight_inv * scale,
"inverse": True,
},
)
for t in bridge_inv
]
G.add_edges_from(edges)
return G
def find_bridging_path(
self,
source: str,
target: str,
via: Optional[str] = None,
avoid: Optional[str] = None,
inverse_weight=1,
prefer_forward: bool = True,
reciprocal=None,
) -> tuple:
"""Find bridging path from source to target.
Parameters
----------
source : str
Source from which to transform to `target`.
target : str
Target to which to transform to.
via : str | list thereof, optional
Force specific intermediate template(s). Multiple
templates are visited in the given order. We use the
cheapest path between each pair of waypoints which means
the full path may go through a template more than once.
avoid : str | list thereof, optional
Avoid going through specific intermediate template(s).
inverse_weight : bool | float
What to charge for traversing a transform backwards. See
`TemplateRegistry.bridging_graph`. Lower = more likely to
be used.
prefer_forward : bool
Where two templates are connected by both a purpose-built
registration and the inverse of its counterpart, use the
purpose-built one - regardless of weight. Set to False to
pick on weight alone, i.e. to take your graph's weights
entirely at face value.
reciprocal : bool | float
Deprecated alias for `inverse_weight`.
Returns
-------
path : list
Path from source to target: [source, ..., target]
transforms : list
Transforms as [[path_to_transform, inverse], ...]
"""
inverse_weight = _deprecate_reciprocal(reciprocal, inverse_weight)
# Generate (or get cached) bridging graph
G = self.bridging_graph(inverse_weight=inverse_weight)
if len(G) == 0:
raise ValueError("No bridging registrations available")
# Do not remove the conversion to list - fuzzy matching does act up
# otherwise
nodes = list(G.nodes)
if source not in nodes:
best_match = fw.process.extractOne(
source, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Source "{source}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
if target not in G.nodes:
best_match = fw.process.extractOne(
target, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Target "{target}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
if via:
via = list(utils.make_iterable(via)) # do not remove the list() here
for v in via:
if v not in G.nodes:
best_match = fw.process.extractOne(
v, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Via "{v}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
else:
via = []
if avoid:
avoid = list(utils.make_iterable(avoid))
for v in [source, target] + via:
if v in avoid:
raise ValueError(
f'"{v}" can not be both in `avoid` and source, target or `via`.'
)
# Note: this is a read-only view and does not alter the cached graph
G = G.subgraph([n for n in G.nodes if n not in avoid])
# Find the cheapest path for each leg between consecutive waypoints. Note
# that this deliberately allows the path to pass through the same template
# more than once: e.g. if `via` is a dead end (B in A -> B -> A -> C).
waypoints = [source] + via + [target]
path = [source]
for n1, n2 in zip(waypoints[:-1], waypoints[1:]):
try:
path += nx.shortest_path(G, n1, n2, weight="weight")[1:]
except nx.NetworkXNoPath:
msg = f"No bridging path connecting {source} and {target}"
if via:
msg += f" via {', '.join(map(str, via))}"
if avoid:
msg += f" avoiding {', '.join(map(str, avoid))}"
if via:
msg += f" (no path from {n1} to {n2})"
raise nx.NetworkXNoPath(f"{msg}.") from None
if len(set(path)) < len(path):
logger.warning(f"Bridging sequence contains loop: {' -> '.join(path)}")
# `path` holds the sequence of nodes we are traversing but not which
# transforms (i.e. edges) to use
transforms = [
_pick_edge(G, n1, n2, prefer_forward=prefer_forward)
for n1, n2 in zip(path[:-1], path[1:])
]
return path, transforms
def find_all_bridging_paths(
self,
source: str,
target: str,
via: Optional[str] = None,
avoid: Optional[str] = None,
inverse_weight=1,
prefer_forward: bool = True,
cutoff: int = None,
reciprocal=None,
) -> tuple:
"""Find all bridging paths from source to target.
Parameters
----------
source : str
Source from which to transform to `target`.
target : str
Target to which to transform to.
via : str | list thereof, optional
Force specific intermediate template(s).
avoid : str | list thereof, optional
Avoid specific intermediate template(s).
inverse_weight : bool | float
What to charge for traversing a transform backwards. See
`TemplateRegistry.bridging_graph`. Lower = more likely to
be used.
prefer_forward : bool
Where two templates are connected by both a purpose-built
registration and the inverse of its counterpart, use the
purpose-built one - regardless of weight. See
`TemplateRegistry.find_bridging_path`.
cutoff : int, optional
Depth to stop the search. Only paths of length
<= cutoff are returned.
reciprocal : bool | float
Deprecated alias for `inverse_weight`.
Returns
-------
path : list
Path from source to target: [source, ..., target]
transforms : list
Transforms as [[path_to_transform, inverse], ...]
"""
inverse_weight = _deprecate_reciprocal(reciprocal, inverse_weight)
# Generate (or get cached) bridging graph
G = self.bridging_graph(inverse_weight=inverse_weight)
if len(G) == 0:
raise ValueError("No bridging registrations available")
# Do not remove the conversion to list - fuzzy matching does act up
# otherwise
nodes = list(G.nodes)
if source not in nodes:
best_match = fw.process.extractOne(
source, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Source "{source}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
if target not in G.nodes:
best_match = fw.process.extractOne(
target, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Target "{target}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
if via and via not in G.nodes:
best_match = fw.process.extractOne(
via, nodes, scorer=fw.fuzz.token_sort_ratio
)
raise ValueError(
f'Via "{via}" has no known bridging '
f'registrations. Did you mean "{best_match[0]}" '
"instead?"
)
# This will raise a error message if no path is found
for path in nx.all_simple_paths(G, source, target, cutoff=cutoff):
# Skip paths that don't contain `via`
if isinstance(via, str) and (via not in path):
continue
elif isinstance(via, (list, tuple, np.ndarray)) and not all(
[v in path for v in via]
):
continue
# Skip paths that contain `avoid`
if isinstance(avoid, str) and (avoid in path):
continue
elif isinstance(avoid, (list, tuple, np.ndarray)) and any(
[v in path for v in avoid]
):
continue
# `path` holds the sequence of nodes we are traversing but not which
# transforms (i.e. edges) to use
transforms = [
_pick_edge(G, n1, n2, prefer_forward=prefer_forward)
for n1, n2 in zip(path[:-1], path[1:])
]
yield path, transforms
@functools.lru_cache()
def shortest_bridging_seq(
self,
source: str,
target: str,
via: Optional[str] = None,
inverse_weight: float = 1,
prefer_forward: bool = True,
) -> tuple:
"""Find shortest bridging sequence to get from source to target.
Parameters
----------
source : str
Source from which to transform to `target`.
target : str
Target to which to transform to.
via : str | list of str
Waystations to traverse on the way from source to
target.
inverse_weight : float
Scales the cost of traversing a transform backwards.
The default of `1` takes the graph's weights at face
value: each transform already declares how expensive it
is to invert (see `register_transform`). Raise it to
make navis detour further to avoid going backwards at
all. Remember lower weight = more likely to be used.
prefer_forward : bool
Where two templates are connected by both a
purpose-built registration and the inverse of its
counterpart, use the purpose-built one - regardless of
weight. Set to False to pick on weight alone.
Returns
-------
sequence : (N, ) array
Sequence of registrations that will be traversed.
transform_seq : TransformSequence
Class that collates the required transforms to get
from source to target.
"""
path, transforms = self.find_bridging_path(
source,
target,
via=via,
inverse_weight=inverse_weight,
prefer_forward=prefer_forward,
)
return np.array(path), TransformSequence(*transforms)
def find_mirror_reg(self, template: str, non_found: str = "raise") -> tuple:
"""Search for a mirror transformation for given template.
Typically a mirror transformation specifies a non-rigid transformation
to correct asymmetries in an image.
Parameters
----------
template : str
Name of the template to find a mirror transformation for.
non_found : "raise" | "ignore"
What to do if no mirror transformation is found. If "ignore"
and no mirror transformation found, will silently return
`None`.
Returns
-------
tuple
Named tuple containing a mirror transformation. Will only
ever return one - even if multiple are available.
"""
for tr in self.mirrors:
if tr.source == template:
return tr
if non_found == "raise":
raise ValueError(f"No mirror transformation found for {template}")
return None
def find_closest_mirror_reg(self, template: str, non_found: str = "raise") -> str:
"""Search for the closest mirror transformation for given template.
Typically a mirror transformation specifies a non-rigid transformation
to correct asymmetries in an image.
Parameters
----------
template : str
Name of the template to find a mirror transformation for.
non_found : "raise" | "ignore"
What to do if there is no path to a mirror transformation.
If "ignore" and no path is found, will silently return
`None`.
Returns
-------
str
Name of the closest template with a mirror transform.
"""
# Templates with mirror registrations
temps_w_mirrors = [t.source for t in self.mirrors]
# Add symmetrical template brains
temps_w_mirrors += [
t.label for t in self.templates if getattr(t, "symmetrical", False) == True
]
if not temps_w_mirrors:
raise ValueError("No mirror transformations registered")
# If this template has a mirror registration:
if template in temps_w_mirrors:
return template
# Get bridging graph
G = self.bridging_graph()
if template not in G.nodes:
raise ValueError(
f'"{template}" does not appear to be a registered template'
)
# Get path lengths from template to all other nodes
pl = nx.single_source_dijkstra_path_length(G, template)
# Subset to targets that have a mirror reg
pl = {k: v for k, v in pl.items() if k in temps_w_mirrors}
# Find the closest mirror
cl = sorted(pl.keys(), key=lambda x: pl[x])
# If any, return the closests
if cl:
return cl[0]
if non_found == "raise":
raise ValueError(
f'No path to a mirror transformation found for "{template}"'
)
return None
def find_template(self, name: str, non_found: str = "raise") -> "TemplateBrain":
"""Search for a given template (brain).
Parameters
----------
name : str
Name of the template to find a mirror transformation for.
Searches against `name` and `label` (short name) properties
of registered templates.
non_found : "raise" | "ignore"
What to do if no mirror transformation is found. If "ignore"
and no mirror transformation found, will silently return
`None`.
Returns
-------
TemplateBrain
"""
for tmp in self.templates:
if getattr(tmp, "label", None) == name:
return tmp
if getattr(tmp, "name", None) == name:
return tmp
if non_found == "raise":
raise ValueError(f'No template brain registered that matches "{name}"')
return None
def plot_bridging_graph(self, **kwargs):
"""Draw bridging graph using networkX.
Parameters
----------
**kwargs
Keyword arguments are passed to `networkx.draw_networkx`.
Returns
-------
None
"""
# Get graph
G = self.bridging_graph(inverse_weight=False)
# Draw nodes and edges
node_labels = {n: n for n in G.nodes}
pos = nx.kamada_kawai_layout(G)
# Draw all nodes
nx.draw_networkx_nodes(
G, pos=pos, node_color="lightgrey", node_shape="o", node_size=300
)
nx.draw_networkx_labels(
G, pos=pos, labels=node_labels, font_color="k", font_size=10
)
# Draw edges by type of transform
edge_types = set([e[2]["type"] for e in G.edges(data=True)])
lines = []
labels = []
for t, c in zip(edge_types, sns.color_palette("muted", len(edge_types))):
subset = [e for e in G.edges(data=True) if e[2]["type"] == t]
nx.draw_networkx_edges(
G, pos=pos, edgelist=subset, edge_color=mcl.to_hex(c), width=1.5
)
lines.append(Line2D([0], [0], color=c, linewidth=2, linestyle="-"))
labels.append(t)
plt.legend(lines, labels)
def xform_brain(
x: Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"],
source: str,
target: str,
via: Optional[str] = None,
avoid: Optional[str] = None,
affine_fallback: bool = True,
caching: bool = True,
verbose: bool = True,
) -> Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"]:
"""Transform 3D data between template brains.
This requires the appropriate transforms to be registered with `navis`.
See the docs/tutorials for details.
Notes
-----
For Neurons only: transforms can introduce a change in the units (e.g. if
the transform goes from micron to nanometer space). Some template brains have
their units hard-coded in their meta data (as `_navis_units`). If that's
not the case we fall-back to trying to infer any change in units by comparing
distances between x/y/z coordinate before and after the transform. That
approach works reasonably well with base 10 increments (e.g. nm -> um) but
may be off with odd changes in units (e.g. physical -> voxel space).
Regardless of whether hard-coded or inferred, any change in units is used to
update the `.units` property and node/soma radii for Skeletons.
Parameters
----------
x : Neuron/List | numpy.ndarray | pandas.DataFrame
Data to transform. Dataframe must contain `['x', 'y', 'z']`
columns. Numpy array must be shape `(N, 3)`.
source : str
Source template brain that the data currently is in.
target : str
Target template brain that the data should be
transformed into.
via : str | list thereof, optional
Optionally set intermediate template(s). This can be
helpful to force a specific transformation sequence.
Multiple templates are visited in the given order using
the cheapest path between each of them.
avoid : str | list thereof, optional
Prohibit going through specific intermediate template(s).
affine_fallback : bool
In some cases the non-rigid transformation of points
can fail - for example if points are outside the
deformation field. If that happens, they will be
returned as `NaN`. If `affine_fallback=True`
we will apply only the rigid affine part of the
transformation to those points to get as close as
possible to the correct coordinates.
caching : bool
If True, will (pre-)cache data for transforms whenever
possible. Depending on the data and the type of
transforms this can speed things up significantly at the
cost of increased memory usage:
- `False` = no upfront cost, lower memory footprint
- `True` = higher upfront cost, most definitely faster
Only applies if input is NeuronList and if transforms
include H5 transform.
verbose : bool
If True, will print some useful info on transform.
Returns
-------
same type as `x`
Copy of input with transformed coordinates.
Examples
--------
This example requires the
[flybrains](https://github.com/navis-org/navis-flybrains)
library to be installed: `pip3 install flybrains`
Also, if you haven't already, you will need to have the optional Saalfeld
lab (Janelia Research Campus) transforms installed (this is a one-off):
>>> import flybrains # doctest: +SKIP
>>> flybrains.download_jrc_transforms() # doctest: +SKIP
Once `flybrains` is installed and you have downloaded the registrations,
you can run this:
>>> import navis
>>> import flybrains
>>> # navis example neurons are in raw (8nm voxel) hemibrain (JRCFIB2018Fraw) space
>>> n = navis.example_neurons(1)
>>> # Transform to FAFB14 space
>>> xf = navis.xform_brain(n, source='JRCFIB2018Fraw', target='FAFB14') # doctest: +SKIP
See Also
--------
[`navis.xform`][]
Lower level entry point that takes data and applies a given
transform or sequence thereof.
[`navis.mirror_brain`][]
Uses non-rigid transforms to mirror neurons from the left
to the right side of given template brain and vice versa.
"""
if not isinstance(source, str):
TypeError(f'Expected source of type str, got "{type(source)}"')
if not isinstance(target, str):
TypeError(f'Expected target of type str, got "{type(target)}"')
# Get the transformation sequence
path, transforms = registry.find_bridging_path(source, target, via=via, avoid=avoid)
if verbose:
path_str = path[0]
for p, tr in zip(path[1:], transforms):
if isinstance(tr, AliasTransform):
link = "="
else:
link = "->"
path_str += f" {link} {p}"
print("Transform path:", path_str)
# Combine into transform sequence
trans_seq = TransformSequence(*transforms)
# Apply transform and returned xformed points
xf = xform(x, transform=trans_seq, caching=caching, affine_fallback=affine_fallback)
# We might be able to set the correct units based on the target template's
# meta data (the "guessed" new units can be off if the transform is
# not base 10 which happens for e.g. voxels -> physical space)
if isinstance(xf, (core.NeuronList, core.BaseNeuron)):
# First we need to find the last non-alias template space
for tmp, tr in zip(path[::-1], transforms[::-1]):
if not isinstance(tr, AliasTransform):
# There is a chance that there is no meta data for this template
try:
last_temp = registry.find_template(tmp)
except ValueError:
break
except BaseException:
raise
# If this template brain has a property for navis units
if hasattr(last_temp, "_navis_units"):
for n in core.NeuronList(xf):
n.units = last_temp._navis_units
break
return xf
def symmetrize_brain(
x: Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"],
template: Union[str, "TemplateBrain"],
via: Optional[str] = "auto",
progress: bool = True,
verbose: bool = False,
) -> Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"]:
"""Symmetrize 3D object (neuron, coordinates).
The way this works is by:
1. Finding the closest mirror transform (unless provided)
2. Mirror data on the left-hand-side to the right-hand-side using the
proper (warp) mirror transform to offset deformations
3. Simply flip that data back to the left-hand-side
This works reasonably well but may produce odd results around the midline.
For high quality symmetrization you are better off generating dedicated
transform (see `navis-flybrains` for an example).
Parameters
----------
x : Neuron/List | Volume/trimesh | numpy.ndarray | pandas.DataFrame
Data to transform. Dataframe must contain `['x', 'y', 'z']`
columns. Numpy array must be shape `(N, 3)`.
template : str | TemplateBrain
Source template brain space that the data is in. If string
will be searched against registered template brains.
via : "auto" | str
By default ("auto") it will find and apply the closest
mirror transform. You can also specify a template that
should be used. That template must have a mirror transform!
progress : bool
Whether to show a progress bar when symmetrizing multiple
neurons.
verbose : bool
If True, will print some useful info on the transform(s).
Returns
-------
xs
Same object type as input (array, neurons, etc) but
hopefully symmetrical.
Examples
--------
This example requires the
[flybrains](https://github.com/navis-org/navis-flybrains)
library to be installed: `pip3 install flybrains`
>>> import navis
>>> import flybrains
>>> # Get the FAFB14 neuropil mesh
>>> m = flybrains.FAFB14.mesh
>>> # Symmetrize the mesh
>>> s = navis.symmetrize_brain(m, template='FAFB14')
>>> # Plot side-by-side for comparison
>>> m.plot3d() # doctest: +SKIP
>>> s.plot3d(color=(1, 0, 0)) # doctest: +SKIP
"""
if not isinstance(template, str):
TypeError(f'Expected template of type str, got "{type(template)}"')
if via == "auto":
# Find closest mirror transform
via = registry.find_closest_mirror_reg(template)
if isinstance(x, core.NeuronList):
if len(x) == 1:
x = x[0]
else:
xf = []
for n in config.tqdm(
x,
desc="Mirroring",
disable=config.pbar_hide or not progress,
leave=config.pbar_leave,
):
xf.append(symmetrize_brain(n, template=template, via=via))
return core.NeuronList(xf)
if isinstance(x, core.BaseNeuron):
x = x.copy()
if isinstance(x, core.Skeleton):
x.nodes = symmetrize_brain(x.nodes, template=template, via=via)
elif isinstance(x, core.Dotprops):
x.points = symmetrize_brain(x.points, template=template, via=via)
# Set tangent vectors and alpha to None so they will be regenerated
x._vect = x._alpha = None
elif isinstance(x, core.Mesh):
x.vertices = symmetrize_brain(x.vertices, template=template, via=via)
else:
raise TypeError(f"Don't know how to transform neuron of type '{type(x)}'")
if x.has_connectors:
x.connectors = symmetrize_brain(x.connectors, template=template, via=via)
return x
elif isinstance(x, tm.Trimesh):
x = x.copy()
x.vertices = symmetrize_brain(x.vertices, template=template, via=via)
return x
elif isinstance(x, pd.DataFrame):
if any([c not in x.columns for c in ["x", "y", "z"]]):
raise ValueError("DataFrame must have x, y and z columns.")
x = x.copy()
x[["x", "y", "z"]] = symmetrize_brain(
x[["x", "y", "z"]].values.astype(float), template=template, via=via
)
return x
else:
try:
# At this point we expect numpy arrays
x = np.asarray(x)
except BaseException:
raise TypeError(f'Unable to transform data of type "{type(x)}"')
if not x.ndim == 2 or x.shape[1] != 3:
raise ValueError("Array must be of shape (N, 3).")
# Now find the meta info for this template brain
if isinstance(template, TemplateBrain):
tb = template
else:
tb = registry.find_template(template, non_found="raise")
# Get the bounding box
if not hasattr(tb, "boundingbox"):
raise ValueError(f'Template "{tb.label}" has no bounding box info.')
if not isinstance(tb.boundingbox, (list, tuple, np.ndarray)):
raise TypeError(
"Expected the template brain's bounding box to be a "
f"list, tuple or array - got '{type(tb.boundingbox)}'"
)
# Get bounding box of template brain
bbox = np.asarray(tb.boundingbox)
# Reshape if flat array
if bbox.ndim == 1:
bbox = bbox.reshape(3, 2)
# Find points on the left
center = bbox[0][0] + (bbox[0][1] - bbox[0][0]) / 2
is_left = x[:, 0] > center
# Make a copy of the original data
x = x.copy()
# If nothing to symmetrize - return
if is_left.sum() == 0:
return x
# Mirror with compensation for deformations
xm = mirror_brain(
x[is_left], template=template, via=via, mirror_axis="x", verbose=verbose
)
# And now flip them back without compensation for deformations
xmf = mirror_brain(xm, template=template, warp=False, mirror_axis="x")
# Replace values
x[is_left] = xmf
return x
def mirror_brain(
x: Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"],
template: Union[str, "TemplateBrain"],
mirror_axis: Union[Literal["x"], Literal["y"], Literal["z"]] = "auto",
warp: Union[Literal["auto"], bool] = "auto",
via: Optional[str] = None,
verbose: bool = False,
progress: bool = True,
) -> Union["core.NeuronObject", "pd.DataFrame", "np.ndarray"]:
"""Mirror 3D object (neuron, coordinates) about given axis.
The way this works is:
1. Look up the length of the template space along the given axis. For this,
the template space has to be registered (see docs for details).
2. Flip object along midpoint of axis using a affine transformation.
3. (Optional) Apply a warp transform that corrects asymmetries.
Parameters
----------
x : Neuron/List | Volume/trimesh | numpy.ndarray | pandas.DataFrame
Data to transform. Dataframe must contain `['x', 'y', 'z']`
columns. Numpy array must be shape `(N, 3)`.
template : str | TemplateBrain
Source template brain space that the data is in. If string
will be searched against registered template brains.
Alternatively check out [`navis.transforms.mirror`][]
for a lower level interface.
mirror_axis : 'auto' | 'x' | 'y' | 'z', optional
Axis to mirror. If "auto" (default), will try get the correct
mirror axis from the template brain's meta data. If that is
not available, will default to "x".
warp : bool | "auto" | Transform, optional
If 'auto', will check if a non-rigid mirror transformation
exists for the given `template` and apply it after the
flipping. Alternatively, you can also pass a Transform or
TransformSequence directly.
via : str | None
If provided, (e.g. "FCWB") will first transform coordinates
into that space, then mirror and transform back.
Use this if there is no mirror registration for the original
template, or to transform to a symmetrical template in which
flipping is sufficient. Note that `mirror_axis` must match
the mirror axis of the "via" template!
verbose : bool
If True, will print some useful info on the transform(s).
progress : bool
Whether to show a progress bar when mirroring multiple
neurons.
Returns
-------
xf
Same object type as input (array, neurons, etc) but with
transformed coordinates.
Examples
--------
This example requires the
[flybrains](https://github.com/navis-org/navis-flybrains)
library to be installed: `pip3 install flybrains`
Also, if you haven't already, you will need to have the optional Saalfeld
lab (Janelia Research Campus) transforms installed (this is a one-off):
>>> import flybrains # doctest: +SKIP
>>> flybrains.download_jrc_transforms() # doctest: +SKIP
Once `flybrains` is installed and you have downloaded the registrations,
you can run this:
>>> import navis
>>> import flybrains
>>> # navis example neurons are in raw hemibrain (JRCFIB2018Fraw) space
>>> n = navis.example_neurons(1)
>>> # Mirror about x axis (this is a simple flip in this case)
>>> mirrored = navis.mirror_brain(n * 8 / 1000, tem plate='JRCFIB2018F', via='JRC2018F') # doctest: +SKIP
>>> # We also need to get back to raw coordinates
>>> mirrored = mirrored / 8 * 1000 # doctest: +SKIP
See Also
--------
[`navis.mirror`][]
Lower level function for mirroring. You can use this if
you want to mirror data without having a registered
template for it.
"""
utils.eval_param(
mirror_axis,
name="mirror_axis",
allowed_values=("x", "y", "z", "auto"),
on_error="raise",
)
if not isinstance(warp, (BaseTransform, TransformSequence)):
utils.eval_param(
warp, name="warp", allowed_values=("auto", True, False), on_error="raise"
)
# If we go via another brain space
if via and via != template:
# Xform to "via" space
xf = xform_brain(x, source=template, target=via, verbose=verbose)
# Mirror
xfm = mirror_brain(
xf,
template=via,
mirror_axis=mirror_axis,
warp=warp,
progress=progress,
via=None,
)
# Xform back to original template space
xfm_inv = xform_brain(xfm, source=via, target=template, verbose=verbose)
return xfm_inv
if isinstance(x, core.NeuronList):
if len(x) == 1:
x = x[0]
else:
xf = []
for n in config.tqdm(
x,
desc="Mirroring",
disable=config.pbar_hide or not progress,
leave=config.pbar_leave,
):
xf.append(
mirror_brain(
n, template=template, mirror_axis=mirror_axis, warp=warp
)
)
return core.NeuronList(xf)
if isinstance(x, core.BaseNeuron):
x = x.copy()
if isinstance(x, core.Skeleton):
x.nodes = mirror_brain(
x.nodes, template=template, mirror_axis=mirror_axis, warp=warp
)
elif isinstance(x, core.Dotprops):
if isinstance(x.k, type(None)) or x.k <= 0:
# If no k, we need to mirror vectors too. Note that this is less
# than ideal though! Here, we are scaling the vector by the
# dotprop's sampling resolution (i.e. ideally a representative
# distance between the points) because if the vectors are too
# small any warping transform will make them go haywire
hp = mirror_brain(
x.points + x.vect * x.sampling_resolution * 2,
template=template,
mirror_axis=mirror_axis,
warp=warp,
)
x.points = mirror_brain(
x.points, template=template, mirror_axis=mirror_axis, warp=warp
)
if isinstance(x.k, type(None)) or x.k <= 0:
# Re-generate vectors
vect = x.points - hp
vect = vect / np.linalg.norm(vect, axis=1).reshape(-1, 1)
x._vect = vect
else:
# Set tangent vectors and alpha to None so they will be
# regenerated on demand
x._vect = x._alpha = None
elif isinstance(x, core.Mesh):
x.vertices = mirror_brain(
x.vertices, template=template, mirror_axis=mirror_axis, warp=warp
)
# We also need to flip the normals
x.faces = x.faces[:, ::-1]
else:
raise TypeError(f"Don't know how to transform neuron of type '{type(x)}'")
if x.has_connectors:
x.connectors = mirror_brain(
x.connectors, template=template, mirror_axis=mirror_axis, warp=warp
)
return x
elif isinstance(x, tm.Trimesh):
x = x.copy()
x.vertices = mirror_brain(
x.vertices, template=template, mirror_axis=mirror_axis, warp=warp
)
# We also need to flip the normals
x.faces = x.faces[:, ::-1]
return x
elif isinstance(x, pd.DataFrame):
if any([c not in x.columns for c in ["x", "y", "z"]]):
raise ValueError("DataFrame must have x, y and z columns.")
x = x.copy()
x[["x", "y", "z"]] = mirror_brain(
x[["x", "y", "z"]].values,
template=template,
mirror_axis=mirror_axis,
warp=warp,
)
return x
else:
try:
# At this point we expect numpy arrays
x = np.asarray(x)
except BaseException:
raise TypeError(f'Unable to transform data of type "{type(x)}"')
if not x.ndim == 2 or x.shape[1] != 3:
raise ValueError("Array must be of shape (N, 3).")
if not isinstance(template, str):
TypeError(f'Expected template of type str, got "{type(template)}"')
if isinstance(warp, (BaseTransform, TransformSequence)):
mirror_trans = warp
elif warp:
# See if there is a mirror registration
mirror_trans = registry.find_mirror_reg(template, non_found="ignore")
# Get actual transform from tuple
if mirror_trans:
mirror_trans = mirror_trans.transform
# If warp was not "auto" and we didn't find a registration, raise
elif warp != "auto" and not mirror_trans:
raise ValueError(f'No mirror transform found for "{template}"')
else:
mirror_trans = None
# Now find the meta info about the template brain
if isinstance(template, TemplateBrain):
tb = template
else:
tb = registry.find_template(template, non_found="raise")
# Get the bounding box
if not hasattr(tb, "boundingbox"):
raise ValueError(f'Template "{tb.label}" has no bounding box info.')
if not isinstance(tb.boundingbox, (list, tuple, np.ndarray)):
raise TypeError(
"Expected the template brain's bounding box to be a "
f"list, tuple or array - got '{type(tb.boundingbox)}'"
)
# Get bounding box of template brain
bbox = np.asarray(tb.boundingbox)
# Reshape if flat array
if bbox.ndim == 1:
bbox = bbox.reshape(3, 2)
if isinstance(mirror_axis, str) and mirror_axis == "auto":
# Try to get mirror axis from template brain meta data
if hasattr(tb, "mirror_axis"):
mirror_axis = tb.mirror_axis
else:
# Default to x axis
mirror_axis = "x"
if verbose:
print(
f'No mirror axis info found for template "{tb.label}", defaulting to "x"'
)
# Index of mirror axis
ix = {"x": 0, "y": 1, "z": 2}[mirror_axis]
if bbox.shape == (3, 2):
# In nat.templatebrains this is using the sum (min+max) but have a
# suspicion that this should be the difference (max-min)
mirror_axis_size = bbox[ix, :].sum()
elif bbox.shape == (2, 3):
mirror_axis_size = bbox[:, ix].sum()
else:
raise ValueError(
f"Expected bounding box to be of shape (3, 2) or (2, 3) got {bbox.shape}"
)
return mirror(
x, mirror_axis=mirror_axis, mirror_axis_size=mirror_axis_size, warp=mirror_trans
)
class TemplateBrain:
"""Generic base class for template brains.
Minimally, a template should have a `name` and `label` property. For
mirroring, it also needs a `boundingbox`.
See [flybrains](https://github.com/navis-org/navis-flybrains) for
an example of how to use template brains.
"""
def __init__(self, **properties):
"""Initialize class."""
for k, v in properties.items():
setattr(self, k, v)
@property
def mesh(self):
"""Mesh represenation of this brain."""
if not hasattr(self, "_mesh"):
name = getattr(self, "regName", getattr(self, "name", None))
raise ValueError(f"{name} does not appear to have a mesh")
return self._mesh
def render_template(
x: "core.NeuronObject",
template: TemplateBrain,
source: Optional[str] = None,
depth: bool = False,
smooth: int = 0,
) -> np.ndarray:
"""Render neurons into template space.
Parameters
----------
x : Skeleton | Mesh | Dotprops | NeuronList
Neuron(s) to render. Uses each neuron's nodes, points or
(solid-voxelized) mesh, respectively. Multiple neurons are
accumulated into the same grid.
template : TemplateBrain
Template to use for bounds, shape and voxel sizes.
source : str, optional
If provided, will first transform the neuron(s) from
`source` template space into the `template` space.
If not provided, will assume that the neuron(s) are already
in the `template` space.
depth : bool
Only affects Meshes: if True, weigh each mesh voxel by
its distance to the surface (via
[`sparsecubes.measure.distance_transform`][]) instead of a
flat occupancy of 1. Thick regions (e.g. the soma) then
contribute more than thin neurites. Skeletons and
Dotprops are unaffected (still binned by point count).
smooth : int
If non-zero, will apply a Gaussian filter with `smooth`
as `sigma`.
Returns
-------
numpy array
3D numpy array with rendered neuron(s) in template space.
The shape of the array is determined by the `template`
bounding box and voxel size.
Examples
--------
This example requires the
[flybrains](https://github.com/navis-org/navis-flybrains)
library to be installed: `pip3 install flybrains`
>>> import navis
>>> import flybrains
>>> # Neurons must be in - or transformed into - the template's space
>>> n = navis.example_neurons(5)
>>> # Render into the JRC2018F template grid
>>> img = navis.render_template(n, template=flybrains.JRC2018F, # doctest: +SKIP
... source='JRCFIB2018Fraw')
"""
if not isinstance(template, TemplateBrain):
raise TypeError(
f"Expected `template` to be of type TemplateBrain, got {type(template)}"
)
for attr in ("dims", "boundingbox", "voxdims"):
if not hasattr(template, attr):
raise ValueError(f'Template "{template.name}" must have `.{attr}` defined.')
pitch = np.asarray(template.voxdims, dtype=float)
bounds = np.asarray(template.boundingbox, dtype=float).reshape((3, 2))
shape = np.asarray(template.dims)
if (bounds[:, 0] >= bounds[:, 1]).any():
raise ValueError(
"Template bounding box must have lower bounds smaller than upper "
"bounds:",
bounds,
)
if shape.ndim != 1 or len(shape) != 3:
raise ValueError(
"Expected template `dims` to be a list, tuple or array of length "
f"3, got {template.dims}"
)
shape = tuple(int(d) for d in shape)
# Voxel index of the bounding box's lower corner. Both the binned points and
# the mesh voxels are mapped with the same round-to-nearest convention used
# by `neuron2voxels`/`sparsecubes`, so the two line up in the same grid.
offset = np.round(bounds[:, 0] / pitch).astype(int)
# Guard against templates whose (fixed-size) grid would exhaust memory
utils.check_grid_size(
shape, np.float32, hint="The template's voxel grid is very large."
)
# Transform the neuron(s) into template space
if source:
x = xform_brain(x, source=source, target=template.name)
from .. import sampling
image = np.zeros(shape, dtype=np.float32)
def _accumulate(voxels, weights=1.0):
"""Add voxels (in template-grid indices) to the image, dropping any
that fall outside the grid."""
voxels = np.asarray(voxels)
if not len(voxels):
return
keep = np.all((voxels >= 0) & (voxels < shape), axis=1)
voxels = voxels[keep]
if not len(voxels):
return
if not np.isscalar(weights):
weights = np.asarray(weights)[keep]
image[voxels[:, 0], voxels[:, 1], voxels[:, 2]] += weights
# Iterate over neurons and fill the image grid
for neuron in core.NeuronList(x):
if isinstance(neuron, core.Mesh):
# Meshes are voxelized properly - walking the surface and filling
# the interior via `sparsecubes` - rather than just binning their
# vertices, which would miss any face larger than a voxel.
with warnings.catch_warnings(record=True) as caught:
warnings.simplefilter("always")
voxels = sparsecubes.voxelize(neuron.trimesh, spacing=pitch)
# Neuron meshes are routinely not watertight, so a `sparsecubes`
# warning about unfilled columns is expected rather than exceptional
# - demote it to a debug log and re-raise anything else.
for w in caught:
if "watertight" in str(w.message):
logger.debug(f"Voxelizing {neuron.id}: {w.message}")
else:
warnings.warn_explicit(
w.message, w.category, w.filename, w.lineno
)
# `sparsecubes` already returns unique voxels in the same
# convention. By default each occupied voxel contributes 1; with
# `depth` it instead contributes its distance to the surface, so
# thick regions weigh more than thin neurites.
if depth:
weights = sparsecubes.measure.distance_transform(
voxels, spacing=pitch
)
_accumulate(voxels - offset, weights)
else:
_accumulate(voxels - offset)
elif isinstance(neuron, (core.Skeleton, core.Dotprops)):
if isinstance(neuron, core.Skeleton):
# Resample first so that long edges don't leave gaps between
# nodes in the grid
neuron = sampling.resample_skeleton(
neuron, resample_to=pitch.min() / 2
)
pts = neuron.nodes[["x", "y", "z"]].values
else:
pts = neuron.points
# Bin the points and accumulate per-voxel counts
voxels = np.round(pts / pitch).astype(int) - offset
voxels, counts = np.unique(voxels, axis=0, return_counts=True)
_accumulate(voxels, counts.astype(np.float32))
else:
raise TypeError(
f"Don't know how to render neuron of type '{type(neuron)}' "
"into template space."
)
# Apply Gaussian filter
if smooth:
from scipy.ndimage import gaussian_filter
image = gaussian_filter(image, sigma=smooth)
return image
# Initialize the registry
registry = TemplateRegistry()

templates.py at commit 4fe56c8, under GPL-3.0 · at the source

Overview

Authors: Tian-Lun Chen^1,2, Qiu-Sui Deng^1,2, Kunzhang Lin³, Xiu-Dan Zheng¹, Xin Wang^1,2, Yong-Wei Zhong¹, Xin-Yu Ning¹, Ying Li¹, Fu-Qiang Xu³, Jiu-Lin Du^1,2,4, Xu-Fei Du^1,2

ORCID iDs: Tian-Lun Chen, Qiu-Sui Deng, Kunzhang Lin, Xiu-Dan Zheng, Xin Wang, Ying Li, Jiu-Lin Du, Xu-Fei Du

Institutions: Center for Excellence in Brain Science and Intelligence Technology (China); University of Chinese Academy of Sciences (China); Shenzhen Institutes of Advanced Technology (China); ShanghaiTech University (China)

Journal: eLife, volume 13, article RP100880

Dates: published online 18 September 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.7554/elife.100880 · PMID 42758538 · PMCID PMC13588618 · OpenAlex W4401973586

Open access: gold, a free copy (OpenAlex)

Status: code verified (how the code is found and verified)

Categories: zebrafish (organism), systems (subfield)

Methods: Statistics, Machine learning, fMRI & imaging, Single-unit activity, calcium imaging

Keywords: circuit tracing, rabies virus, zebrafish, trans-monosynaptic, cerebellum, reconstruction

MeSH: Neurons*, Zebrafish*, Animals, Larva, Rabies virus (* major topic)

Journal subjects: Neuroscience

Topic: Neural dynamics and brain function (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Funding: Brain Science and Brain-like Intelligence Technology - National Science and Technology Major Project (2021ZD0204500, 2021ZD0204502); National Natural Science Foundation of China (32321003, 62320106010); Youth Innovation Promotion Association of the Chinese Academy of Sciences

Citations: cited by 1 paper (Europe PMC); 71 references in the paper

Research resources: RRID:Addgene_240272, RRID:Addgene_240273, RRID:Addgene_240274, SADdG-mCherry[EnvA] RRID:Addgene_32636, CVSdG-tdTomato[EnvA] RRID:Addgene_73462, CVSdG-mCherry-P2A-Cre[EnvA] RRID:Addgene_73472, Fiji (ImageJ) RRID:SCR_002285, ParaView RRID:SCR_002516, GraphPad Prism v9.0 RRID:SCR_002798, Advanced Normalization Tools (ANTs) RRID:SCR_004757, 3D Slicer 5.4.0 RRID:SCR_005619, Python 3.11.5 RRID:SCR_008394, Clampex 10.6 RRID:SCR_011323, Simple Neurite Tracer (SNT) RRID:SCR_016566

Abstract

The larval zebrafish is a vertebrate model for in vivo monitoring and manipulation of whole-brain neuronal activity. Tracing its neural circuits remains challenging. Here, we report an applicable methodology tailored for larval zebrafish to achieve efficient retrograde trans-monosynaptic tracing from genetically defined neurons via EnvA-pseudotyped glycoprotein-deleted rabies viruses. By combinatorially optimizing multiple factors involved, we identified the CVS strain trans-complemented with advanced expression of N2cG at 36 °C as the optimal combination. It yielded a tracing efficiency of up to 20 inputs per starter cell. Its low cytotoxicity enabled the viable labeling and calcium imaging of infected neurons 10 days post-infection, spanning larval ages commonly used for functional examination. Cre-dependent labeling was further developed to enable cell-type-specific input tracing and circuit reconstruction. We mapped cerebellar circuits and uncovered the ipsilateral preference and subtype specificity of granule cell-to-Purkinje cell connections. Our method offers an efficient way for tracing neural circuits in larval zebrafish.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 1 match between paragraphs and lines of code.

navis-org/navis

License: GPL-3.0

State: the link answers, verified on 28 October 2026

Evidence: files inventoried

Commit: 4fe56c87fb8c2b0c9f89ceb3a4beb6dbf8f30839, 24 October 2026

Languages: Python (295), JavaScript (2), Shell (2), Jupyter (1), Java (1)

Size: 470 files, 301 scripts

Software Heritage: archived

Found in: the text, “Cerebellum delineation and neuron reconstruction”

Holds: README, license file, environment (pyproject.toml, requirements.txt, setup.py, binder/postBuild, binder/requirements.txt), tests, continuous integration, documentation, 1 notebook

Not found: CITATION.cff

Tools: NumPy (182 files), pandas (129 files), Matplotlib (57 files), SciPy (48 files), NetworkX (18 files), seaborn (12 files), Plotly (5 files), NEURON (4 files), scikit-image (4 files), h5py (3 files), igraph (2 files), scikit-learn (2 files), NiBabel (1 file), Numba (1 file), tifffile (1 file)

Availability: 2 checks, the latest on 28 October 2026: the link answers

28 October 2026: the link answers
26 September 2026: the link answers

303 files

conftest.py, Python, 33 lines
docs/examples/0_io/tutorial_io_00_skeletons.py, Python, 226 lines
docs/examples/0_io/tutorial_io_01_meshes.py, Python, 120 lines
docs/examples/0_io/tutorial_io_02_dotprops.py, Python, 143 lines
docs/examples/0_io/tutorial_io_03_r.py, Python, 192 lines
docs/examples/0_io/tutorial_io_04_pickle.py, Python, 54 lines
docs/examples/0_io/zzz_tutorial_io_05_skeletonize.py, Python, 252 lines
docs/examples/1a_plotting_general/tutorial_plotting_00_intro.py, Python, 354 lines
docs/examples/1a_plotting_general/tutorial_plotting_01_colors.py, Python, 307 lines
docs/examples/1b_plotting_2d/tutorial_plotting_2d_00_skeletons.py, Python, 195 lines
docs/examples/1b_plotting_2d/tutorial_plotting_2d_01_meshes.py, Python, 206 lines
docs/examples/1b_plotting_2d/tutorial_plotting_2d_02_volumes.py, Python, 178 lines
docs/examples/1c_plotting_3d/tutorial_plotting_3d_00_skeletons.py, Python, 201 lines
docs/examples/1c_plotting_3d/tutorial_plotting_3d_01_meshes.py, Python, 150 lines
docs/examples/1c_plotting_3d/tutorial_plotting_3d_02_volumes.py, Python, 161 lines
docs/examples/1d_plotting_misc/tutorial_plotting_misc_00_connectors.py, Python, 353 lines
docs/examples/1d_plotting_misc/tutorial_plotting_misc_01_barcode.py, Python, 100 lines
docs/examples/1d_plotting_misc/tutorial_plotting_misc_02_topology.py, Python, 129 lines
docs/examples/1d_plotting_misc/tutorial_plotting_misc_03_xkcd.py, Python, 59 lines
docs/examples/1d_plotting_misc/zzz_tutorial_plotting_misc_04_collage.py, Python, 378 lines
docs/examples/1e_plotting_examples/tutorial_plotting_ex_00_cortex.py, Python, 300 lines
docs/examples/2_morpho/tutorial_morpho_00_manipulate.py, Python, 451 lines
docs/examples/2_morpho/tutorial_morpho_01_analyze.py, Python, 338 lines
docs/examples/2_morpho/tutorial_morpho_02_label_prop.py, Python, 167 lines
docs/examples/2_morpho/tutorial_morpho_03_ad_split.py, Python, 204 lines
docs/examples/2_morpho/zzz_tutorial_morpho_05_ivscc.py, Python, 476 lines
docs/examples/2_morpho/zzz_tutorial_morpho_06_ivscc_em.py, Python, 567 lines
docs/examples/3_interfaces/tutorial_interfaces_00_neuron.py, Python, 332 lines
docs/examples/3_interfaces/tutorial_interfaces_01_neuron2.py, Python, 190 lines
docs/examples/3_interfaces/tutorial_interfaces_02_blender.py, Python, 165 lines
docs/examples/4_remote/tutorial_remote_00_neuprint.py, Python, 101 lines
docs/examples/4_remote/tutorial_remote_01_cloudvolume.py, Python, 110 lines
docs/examples/4_remote/tutorial_remote_02_microns.py, Python, 199 lines
docs/examples/4_remote/tutorial_remote_03_insect_db.py, Python, 122 lines
docs/examples/4_remote/tutorial_remote_04_h01.py, Python, 163 lines
docs/examples/4_remote/tutorial_remote_05_bil.py, Python, 99 lines
docs/examples/5_nblast/tutorial_nblast_00_intro.py, Python, 456 lines
docs/examples/5_nblast/tutorial_nblast_03_smat.py, Python, 147 lines
docs/examples/5_nblast/zzz_tutorial_nblast_01_flycircuit.py, Python, 159 lines
docs/examples/5_nblast/zzz_tutorial_nblast_02_hemibrain.py, Python, 160 lines
docs/examples/6_misc/tutorial_misc_00_multiprocess.py, Python, 444 lines
docs/examples/6_misc/tutorial_misc_01_transforms.py, Python, 471 lines
docs/examples/7_ml/tutorial_ml_00_normalize.py, Python, 209 lines
docs/examples/7_ml/tutorial_ml_01_sampling.py, Python, 486 lines
docs/examples/7_ml/tutorial_ml_02_augment.py, Python, 184 lines
docs/examples/tutorial_basic_00_basics.py, Python, 139 lines
docs/examples/tutorial_basic_01_neurons.py, Python, 625 lines
docs/examples/tutorial_basic_02_neuronlists.py, Python, 364 lines
docs/examples/tutorial_basic_03_masking.py, Python, 537 lines
docs/examples/tutorial_basic_04_attach.py, Python, 711 lines
docs/gallery_conf.py, Python, 26 lines
docs/javascripts/katex.js, JavaScript, 10 lines
docs/javascripts/mathjax.js, JavaScript, 19 lines
docs/tools/__init__.py, Python, 1 line
docs/tools/nb_to_doc.py, Python, 32 lines
download_test_data.sh, Shell, 21 lines
examples/colab.ipynb, Jupyter, 207 lines
main.py, Python, 24 lines
navis/__init__.py, Python, 41 lines
navis/__version__.py, Python, 15 lines
navis/_deprecated.py, Python, 321 lines
navis/compute/__init__.py, Python, 75 lines
navis/compute/backends/__init__.py, Python, 64 lines
navis/compute/backends/_dask.py, Python, 176 lines
navis/compute/backends/_joblib.py, Python, 147 lines
navis/compute/backends/_pathos.py, Python, 58 lines
navis/compute/backends/_submitit.py, Python, 163 lines
navis/compute/backends/base.py, Python, 769 lines
navis/compute/backends/local.py, Python, 184 lines
navis/compute/dispatch.py, Python, 641 lines
navis/compute/threads.py, Python, 188 lines
navis/config.py, Python, 337 lines
navis/conftest.py, Python, 27 lines
navis/connectivity/__init__.py, Python, 22 lines
navis/connectivity/adjacency.py, Python, 236 lines
navis/connectivity/cnmetrics.py, Python, 118 lines
navis/connectivity/matrix_utils.py, Python, 135 lines
navis/connectivity/predict.py, Python, 181 lines
navis/connectivity/similarity.py, Python, 494 lines
navis/conversion/__init__.py, Python, 19 lines
navis/conversion/converters.py, Python, 884 lines
navis/conversion/meshing.py, Python, 285 lines
navis/conversion/wrappers.py, Python, 204 lines
navis/core/__init__.py, Python, 35 lines
navis/core/base.py, Python, 1,781 lines
navis/core/core_utils.py, Python, 838 lines
navis/core/dotprop.py, Python, 713 lines
navis/core/masking.py, Python, 367 lines
navis/core/mesh.py, Python, 725 lines
navis/core/neuronlist.py, Python, 1,281 lines
navis/core/neurons.py, Python, 22 lines
navis/core/pipeline.py, Python, 824 lines
navis/core/schema.py, Python, 2,525 lines
navis/core/skeleton.py, Python, 1,626 lines
navis/core/volumes.py, Python, 738 lines
navis/core/voxel.py, Python, 1,503 lines
navis/data/__init__.py, Python, 17 lines
navis/data/load_data.py, Python, 220 lines
navis/graph/__init__.py, Python, 86 lines
navis/graph/clinic.py, Python, 246 lines
navis/graph/converters.py, Python, 926 lines
navis/graph/graph_utils.py, Python, 3,635 lines
navis/interfaces/__init__.py, Python, 46 lines
navis/interfaces/allen_celltypes.py, Python, 119 lines
navis/interfaces/base.py, Python, 426 lines
navis/interfaces/blender.py, Python, 1,255 lines
navis/interfaces/brain_image_library.py, Python, 1,258 lines
navis/interfaces/cajal.py, Python, 910 lines
navis/interfaces/cave_utils.py, Python, 494 lines
navis/interfaces/h01.py, Python, 116 lines
navis/interfaces/insectbrain_db.py, Python, 736 lines
navis/interfaces/microns.py, Python, 205 lines
navis/interfaces/neuprint.py, Python, 1,003 lines
navis/interfaces/neuromorpho.py, Python, 317 lines
navis/interfaces/neuron/__init__.py, Python, 2 lines
navis/interfaces/neuron/comp.py, Python, 924 lines
navis/interfaces/neuron/network.py, Python, 861 lines
navis/interfaces/neuron/utils.py, Python, 39 lines
navis/interfaces/vfb.py, Python, 351 lines
navis/intersection/__init__.py, Python, 17 lines
navis/intersection/convex.py, Python, 55 lines
navis/intersection/intersect.py, Python, 408 lines
navis/intersection/ray.py, Python, 119 lines
navis/io/__init__.py, Python, 34 lines
navis/io/base.py, Python, 2,028 lines
navis/io/hdf_io.py, Python, 1,127 lines
navis/io/json_io.py, Python, 161 lines
navis/io/mesh_io.py, Python, 341 lines
navis/io/nmx_io.py, Python, 377 lines
navis/io/nrrd_io.py, Python, 376 lines
navis/io/pq_io.py, Python, 1,251 lines
navis/io/precomputed_io.py, Python, 686 lines
navis/io/rda_io.py, Python, 1,129 lines
navis/io/swc_io.py, Python, 755 lines
navis/io/tiff_io.py, Python, 294 lines
navis/matching/__init__.py, Python, 17 lines
navis/matching/bipartite.py, Python, 242 lines
navis/matching/pipeline.py, Python, 210 lines
navis/meshes/__init__.py, Python, 19 lines
navis/meshes/internals.py, Python, 260 lines
navis/meshes/mesh_utils.py, Python, 721 lines
navis/meshes/operations.py, Python, 339 lines
navis/ml/__init__.py, Python, 50 lines
navis/ml/augment.py, Python, 686 lines
navis/ml/chunk.py, Python, 1,098 lines
navis/ml/normalize.py, Python, 316 lines
navis/models/__init__.py, Python, 14 lines
navis/models/network_models.py, Python, 658 lines
navis/morpho/__init__.py, Python, 47 lines
navis/morpho/analyze.py, Python, 555 lines
navis/morpho/angles.py, Python, 370 lines
navis/morpho/caps.py, Python, 154 lines
navis/morpho/fq.py, Python, 163 lines
navis/morpho/heal.py, Python, 239 lines
navis/morpho/images.py, Python, 256 lines
navis/morpho/ivscc.py, Python, 840 lines
navis/morpho/manipulation.py, Python, 2,596 lines
navis/morpho/mmetrics.py, Python, 1,585 lines
navis/morpho/persistence.py, Python, 428 lines
navis/morpho/subset.py, Python, 582 lines
navis/nbl/__init__.py, Python, 35 lines
navis/nbl/ablast_funcs.py, Python, 551 lines
navis/nbl/backends/__init__.py, Python, 43 lines
navis/nbl/backends/base.py, Python, 216 lines
navis/nbl/backends/builtin.py, Python, 534 lines
navis/nbl/backends/fastcore.py, Python, 290 lines
navis/nbl/base.py, Python, 175 lines
navis/nbl/nblast_funcs.py, Python, 1,412 lines
navis/nbl/smat.py, Python, 1,141 lines
navis/nbl/synblast_funcs.py, Python, 395 lines
navis/nbl/utils.py, Python, 555 lines
navis/plotting/__init__.py, Python, 24 lines
navis/plotting/_common.py, Python, 436 lines
navis/plotting/collage.py, Python, 1,015 lines
navis/plotting/colors.py, Python, 805 lines
navis/plotting/d.py, Python, 194 lines
navis/plotting/dd.py, Python, 2,888 lines
navis/plotting/ddd.py, Python, 837 lines
navis/plotting/flat.py, Python, 541 lines
navis/plotting/k3d/__init__.py, Python, 1 line
navis/plotting/k3d/conftest.py, Python, 9 lines
navis/plotting/k3d/k3d_objects.py, Python, 455 lines
navis/plotting/plot_utils.py, Python, 796 lines
navis/plotting/plotly/__init__.py, Python, 1 line
navis/plotting/plotly/conftest.py, Python, 9 lines
navis/plotting/plotly/graph_objs.py, Python, 830 lines
navis/plotting/render.py, Python, 307 lines
navis/plotting/settings.py, Python, 297 lines
navis/plotting/viewer_utils.py, Python, 109 lines
navis/sampling/__init__.py, Python, 23 lines
navis/sampling/downsampling.py, Python, 486 lines
navis/sampling/points.py, Python, 803 lines
navis/sampling/resampling.py, Python, 990 lines
navis/sampling/utils.py, Python, 273 lines
navis/transforms/__init__.py, Python, 30 lines
navis/transforms/affine.py, Python, 119 lines
navis/transforms/align.py, Python, 786 lines
navis/transforms/backends.py, Python, 263 lines
navis/transforms/base.py, Python, 417 lines
navis/transforms/cmtk.py, Python, 945 lines
navis/transforms/elastix.py, Python, 466 lines
navis/transforms/factory.py, Python, 101 lines
navis/transforms/grid.py, Python, 324 lines
navis/transforms/h5reg.py, Python, 740 lines
navis/transforms/h5reg_java.py, Python, 215 lines
navis/transforms/h5reg_numba.py, Python, 298 lines
navis/transforms/images.py, Python, 207 lines
navis/transforms/jars/TransformCoordinates.java, Java, 84 lines
navis/transforms/moving_least_squares.py, Python, 236 lines
navis/transforms/similarity.py, Python, 246 lines
navis/transforms/templates.py, Python, 1,790 lines, 1 match
navis/transforms/thinplate.py, Python, 291 lines
navis/transforms/xfm_funcs.py, Python, 540 lines
navis/utils/__init__.py, Python, 36 lines
navis/utils/cave.py, Python, 238 lines
navis/utils/cv.py, Python, 123 lines
navis/utils/decorators.py, Python, 774 lines
navis/utils/eval.py, Python, 356 lines
navis/utils/exceptions.py, Python, 25 lines
navis/utils/http.py, Python, 145 lines
navis/utils/iterables.py, Python, 135 lines
navis/utils/meshproc.py, Python, 271 lines
navis/utils/misc.py, Python, 576 lines
navis/utils/subclasses.py, Python, 202 lines
navis/utils/validate.py, Python, 147 lines
run_mypy.sh, Shell, 3 lines
scripts/gallery_index_hook.py, Python, 370 lines
scripts/gen_llms_txt.py, Python, 577 lines
scripts/gen_ref_pages.py, Python, 70 lines
scripts/gen_ref_pages2.py, Python, 196 lines
setup.py, Python, 76 lines
stubs/numpy/__init__.py, Python, 1 line
stubs/numpy/linalg.py, Python, 4 lines
stubs/pandas/__init__.py, Python, 1 line
tests/__init__.py, Python, 1 line
tests/conftest.py, Python, 216 lines
tests/fixtures/r_data/generate.py, Python, 41 lines
tests/test_align.py, Python, 196 lines
tests/test_angles.py, Python, 188 lines
tests/test_bil.py, Python, 241 lines
tests/test_caps.py, Python, 195 lines
tests/test_cast_neuron.py, Python, 141 lines
tests/test_cave_patch.py, Python, 211 lines
tests/test_collage.py, Python, 593 lines
tests/test_compute_backends.py, Python, 873 lines
tests/test_compute_cluster.py, Python, 291 lines
tests/test_compute_threads.py, Python, 325 lines
tests/test_connected_components.py, Python, 354 lines
tests/test_connecting_nodes.py, Python, 218 lines
tests/test_connectivity.py, Python, 138 lines
tests/test_deprecated_names.py, Python, 145 lines
tests/test_dotprops.py, Python, 310 lines
tests/test_downsample.py, Python, 378 lines
tests/test_error_messages.py, Python, 206 lines
tests/test_extra_edges.py, Python, 349 lines
tests/test_face_connectivity.py, Python, 409 lines
tests/test_flow_metrics.py, Python, 114 lines
tests/test_geodesic_clusters.py, Python, 223 lines
tests/test_geodesic_nearest.py, Python, 136 lines
tests/test_graph_contracts.py, Python, 639 lines
tests/test_graph_primitives.py, Python, 171 lines
tests/test_guess_change.py, Python, 187 lines
tests/test_heal.py, Python, 412 lines
tests/test_heal_mesh.py, Python, 283 lines
tests/test_interfaces_base.py, Python, 344 lines
tests/test_io.py, Python, 780 lines
tests/test_io_url.py, Python, 131 lines
tests/test_ivscc.py, Python, 401 lines
tests/test_links.py, Python, 1,511 lines
tests/test_llms_txt.py, Python, 223 lines
tests/test_masking.py, Python, 547 lines
tests/test_mesh_ops.py, Python, 611 lines
tests/test_mesh_process.py, Python, 292 lines
tests/test_ml.py, Python, 918 lines
tests/test_models/__init__.py, Python, 1 line
tests/test_models/test_network_models.py, Python, 72 lines
tests/test_morpho_contracts.py, Python, 251 lines
tests/test_nbl/__init__.py, Python, 1 line
tests/test_nbl/test_extract_matches.py, Python, 293 lines
tests/test_nbl/test_nblast_dispatch.py, Python, 259 lines
tests/test_nbl/test_nblast_knn.py, Python, 255 lines
tests/test_nbl/test_partition.py, Python, 131 lines
tests/test_nbl/test_smat.py, Python, 142 lines
tests/test_neuron_methods.py, Python, 467 lines
tests/test_neurons.py, Python, 337 lines
tests/test_node_label_sorting.py, Python, 109 lines
tests/test_parallel.py, Python, 288 lines
tests/test_pipeline.py, Python, 616 lines
tests/test_plotting.py, Python, 2,073 lines
tests/test_propagate_labels.py, Python, 106 lines
tests/test_quiet_logger.py, Python, 121 lines
tests/test_resample.py, Python, 487 lines
tests/test_sample.py, Python, 344 lines
tests/test_schema.py, Python, 613 lines
tests/test_sholl.py, Python, 206 lines
tests/test_smooth.py, Python, 343 lines
tests/test_soma.py, Python, 232 lines
tests/test_transform_backends.py, Python, 1,240 lines
tests/test_transforms.py, Python, 93 lines
tests/test_tutorials.py, Python, 113 lines
tests/test_voxel.py, Python, 1,754 lines
LICENSE, License, 674 lines
README.md, Text, 123 lines

At the source: github.com/navis-org/navis

soaringdu/Proj-RVCT

License: none: the authors keep all their rights

State: the link answers, verified on 26 September 2026

Evidence: files inventoried

Commit: 3781c731b3196f0065720169750699bb6b658d7e, 23 June 2025

Languages: Jupyter (2)

Size: 4 files, 2 scripts

Software Heritage: not archived

Found in: “Data availability”

Holds: 2 notebooks

Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation

Tools: NumPy (2 files), SciPy (2 files), Matplotlib (1 file), OpenCV (1 file), pandas (1 file), scikit-learn (1 file), seaborn (1 file)

Availability: 1 check, the latest on 26 September 2026: the link answers

26 September 2026: the link answers

2 files

calcium.ipynb, Jupyter, 774 lines
visual_stimuli_video.ipynb, Jupyter, 155 lines

At the source: github.com/soaringdu/Proj-RVCT

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
303 scripts, each with its path and the digest of its content;
1 match between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

We have deposited the related zebrafish lines at CZRC (China Zebrafish Resource Center) and uploaded plasmid maps and sequences to Addgene. The viral vectors are available through BrainCase (Shenzhen, China). The neuron reconstructions can be downloaded at https://doi.org/10.12412/BSDC.1748509594.10001. All original code has been deposited at https://github.com/soaringdu/Proj-RVCT (copy archived at soaringdu, 2025). The source data files contain all numerical data used to generate the figures and figure supplements. Any additional information required to reanalyze the data reported in this paper is available upon request.

The following dataset was generated:

DuX ChenT 2025Purkinje Cell Input Atlas in Larval ZebrafishBrain Science Data Center10.12412/BSDC.1748509594.10001

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 11 authors, 6 keywords, 5 MeSH terms, 3 funders, 70 references, 14 RRIDs.

Cite

This paper

Chen, T.-L., Deng, Q.-S., Lin, K., Zheng, X.-D., Wang, X., Zhong, Y.-W., Ning, X.-Y., Li, Y., Xu, F.-Q., Du, J.-L., & Du, X.-F. (2026). An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish. eLife, 13, RP100880. https://doi.org/10.7554/elife.100880

BibTeX

@article{chen2026applicable, author = {Chen, Tian-Lun and Deng, Qiu-Sui and Lin, Kunzhang and Zheng, Xiu-Dan and Wang, Xin and Zhong, Yong-Wei and Ning, Xin-Yu and Li, Ying and Xu, Fu-Qiang and Du, Jiu-Lin and Du, Xu-Fei}, title = {{An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish}}, journal = {eLife}, year = {2026}, month = sep, volume = {13}, pages = {RP100880}, publisher = {eLife Sciences Publications, Ltd}, issn = {2050-084X}, doi = {10.7554/elife.100880}, url = {https://doi.org/10.7554/elife.100880}, pmid = {42758538}, pmcid = {PMC13588618} }

RIS

TY - JOUR AU - Chen, Tian-Lun AU - Deng, Qiu-Sui AU - Lin, Kunzhang AU - Zheng, Xiu-Dan AU - Wang, Xin AU - Zhong, Yong-Wei AU - Ning, Xin-Yu AU - Li, Ying AU - Xu, Fu-Qiang AU - Du, Jiu-Lin AU - Du, Xu-Fei TI - An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish T2 - eLife J2 - eLife PY - 2026 DA - 2026/09/18 VL - 13 SP - RP100880 SN - 2050-084X PB - eLife Sciences Publications, Ltd DO - 10.7554/elife.100880 UR - https://doi.org/10.7554/elife.100880 LA - en ER -

CSL-JSON

{ "id": "10.7554/elife.100880", "type": "article-journal", "title": "An applicable and efficient retrograde monosynaptic circuit mapping tool for larval zebrafish", "container-title": "eLife", "author": [ { "family": "Chen", "given": "Tian-Lun" }, { "family": "Deng", "given": "Qiu-Sui" }, { "family": "Lin", "given": "Kunzhang" }, { "family": "Zheng", "given": "Xiu-Dan" }, { "family": "Wang", "given": "Xin" }, { "family": "Zhong", "given": "Yong-Wei" }, { "family": "Ning", "given": "Xin-Yu" }, { "family": "Li", "given": "Ying" }, { "family": "Xu", "given": "Fu-Qiang" }, { "family": "Du", "given": "Jiu-Lin" }, { "family": "Du", "given": "Xu-Fei" } ], "container-title-short": "eLife", "volume": "13", "page": "RP100880", "DOI": "10.7554/elife.100880", "PMID": "42758538", "PMCID": "PMC13588618", "ISSN": "2050-084X", "publisher": "eLife Sciences Publications, Ltd", "URL": "https://doi.org/10.7554/elife.100880", "language": "en", "issued": { "date-parts": [ [ 2026, 9, 18 ] ] } }

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown

<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.7554/elife.100880.svg)](https://openscicode.org/badge/doi/10.7554/elife.100880)
<!-- oscr-badge:end -->

reStructuredText

.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.7554/elife.100880.svg
   :target: https://openscicode.org/badge/doi/10.7554/elife.100880
   :alt: OSCR

.. oscr-badge:end

HTML

<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.7554/elife.100880"><img src="https://openscicode.org/badge/doi/10.7554/elife.100880.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.