Discrete and differentiated encoding of distinct components of spatial experience occurs within the proximodistal subfields of the dorsoventral axis of the hippocampus.

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 › Data processing and statistical analysis › IEG expression ↔ stardist/bioimageio_utils.py, lines 127–159 · score 0.71 · slide image, cell detection, Fiji, segmented, StarDist, imported

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: 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 · 494 lines · 20 KB · BSD-3-Clause · 1 match

from pathlib import Path
try:
from importlib.metadata import requires
except ImportError:
from importlib_metadata import requires
from zipfile import ZipFile
import numpy as np
import tempfile
from packaging.version import Version
from csbdeep.utils import axes_check_and_normalize, normalize, _raise
DEEPIMAGEJ_MACRO = \
"""
//*******************************************************************
// Date: July-2021
// Credits: StarDist, DeepImageJ
// URL:
// https://github.com/stardist/stardist
// https://deepimagej.github.io/deepimagej
// This macro was adapted from
// https://github.com/deepimagej/imagej-macros/blob/648caa867f6ccb459649d4d3799efa1e2e0c5204/StarDist2D_Post-processing.ijm
// Please cite the respective contributions when using this code.
//*******************************************************************
// Macro to run StarDist postprocessing on 2D images.
// StarDist and deepImageJ plugins need to be installed.
// The macro assumes that the image to process is a stack in which
// the first channel corresponds to the object probability map
// and the remaining channels are the radial distances from each
// pixel to the object boundary.
//*******************************************************************
// Get the name of the image to call it
getDimensions(width, height, channels, slices, frames);
name=getTitle();
probThresh={probThresh};
nmsThresh={nmsThresh};
// Isolate the detection probability scores
run("Make Substack...", "channels=1");
rename("scores");
// Isolate the oriented distances
run("Fire");
selectWindow(name);
run("Delete Slice", "delete=channel");
selectWindow(name);
run("Properties...", "channels=" + maxOf(channels, slices) - 1 + " slices=1 frames=1 pixel_width=1.0000 pixel_height=1.0000 voxel_depth=1.0000");
rename("distances");
run("royal");
// Run StarDist plugin
run("Command From Macro", "command=[de.csbdresden.stardist.StarDist2DNMS], args=['prob':'scores', 'dist':'distances', 'probThresh':'" + probThresh + "', 'nmsThresh':'" + nmsThresh + "', 'outputType':'Both', 'excludeBoundary':'2', 'roiPosition':'Stack', 'verbose':'false'], process=[false]");
"""
def _import(error=True):
try:
from importlib_metadata import metadata
from bioimageio.core.build_spec import build_model # type: ignore
import xarray as xr
import bioimageio.core # type: ignore
except ImportError:
if error:
raise RuntimeError(
"Required libraries are missing for bioimage.io model export.\n"
"Please install StarDist as follows: pip install 'stardist[bioimageio]'\n"
"(You do not need to uninstall StarDist first.)"
)
else:
return None
return metadata, build_model, bioimageio.core, xr
def _create_stardist_dependencies(outdir):
from ruamel.yaml import YAML
from packaging.requirements import Requirement
from tensorflow import __version__ as tf_version
from . import __version__ as stardist_version
# dependencies that start with the name "bioimageio" will be added as conda dependencies
reqs_conda = []
for req_str in requires("stardist"):
req = Requirement(req_str)
if (
req.marker is not None
# only include requirements that are for the "bioimageio" extra
and req.marker.evaluate({'extra': 'bioimageio'})
and not req.marker.evaluate({'extra': ''})
# and package name starts with "bioimageio"
and req.name.startswith('bioimageio')
):
# https://packaging.pypa.io/en/stable/requirements.html
reqs_conda.append(f"{req.name}{req.specifier}")
# only stardist and tensorflow as pip dependencies
v_tf = Version(tf_version)
reqs_pip = (f"stardist>={stardist_version}", f"tensorflow>={v_tf.major}.{v_tf.minor},<{v_tf.major+1}")
# conda environment
env = dict(
name = 'stardist',
channels = ['defaults', 'conda-forge'],
dependencies = [
('python>=3.7,<3.8' if v_tf.major == 1 else 'python>=3.7'),
*reqs_conda,
'pip', {'pip': reqs_pip},
],
)
yaml = YAML(typ='safe')
path = outdir / "environment.yaml"
with open(path, "w") as f:
yaml.dump(env, f)
return f"conda:{path}"
def _create_stardist_doc(outdir):
doc_path = outdir / "README.md"
text = (
"# StarDist Model\n"
"This is a model for object detection with star-convex shapes.\n"
"Please see the [StarDist repository](https://github.com/stardist/stardist) for details."
)
with open(doc_path, "w") as f:
f.write(text)
return doc_path
def _get_stardist_metadata(outdir, model, generate_default_deps):
metadata, *_ = _import()
package_data = metadata("stardist")
doi_2d = "https://doi.org/10.1007/978-3-030-00934-2_30"
doi_3d = "https://doi.org/10.1109/WACV45572.2020.9093435"
authors = {
'Martin Weigert': dict(name='Martin Weigert', github_user='maweigert'),
'Uwe Schmidt': dict(name='Uwe Schmidt', github_user='uschmidt83'),
}
data = dict(
description=package_data["Summary"],
authors=list(authors.get(name.strip(),dict(name=name.strip())) for name in package_data["Author"].split(",")),
git_repo=package_data["Home-Page"],
license=package_data["License"],
cite=[{"text": "Cell Detection with Star-Convex Polygons", "doi": doi_2d},
{"text": "Star-convex Polyhedra for 3D Object Detection and Segmentation in Microscopy", "doi": doi_3d}],
tags=[
'fluorescence-light-microscopy', 'whole-slide-imaging', 'other', # modality
f'{model.config.n_dim}d', # dims
'cells', 'nuclei', # content
'tensorflow', # framework
'fiji', # software
'unet', # network
'instance-segmentation', 'object-detection', # task
'stardist',
],
covers=["https://raw.githubusercontent.com/stardist/stardist/main/images/stardist_logo.jpg"],
documentation=_create_stardist_doc(outdir),
)
if generate_default_deps: # only if requested, as not required for bioimage.io
data['dependencies'] = _create_stardist_dependencies(outdir)
return data
def _predict_tf(model_path, test_input):
import tensorflow as tf
from csbdeep.utils.tf import IS_TF_1
# need to unzip the model assets
model_assets = model_path.parent / "tf_model"
with ZipFile(model_path, "r") as f:
f.extractall(model_assets)
if IS_TF_1:
# make a new graph, i.e. don't use the global default graph
with tf.Graph().as_default():
with tf.Session() as sess:
tf_model = tf.saved_model.load_v2(str(model_assets))
x = tf.convert_to_tensor(test_input, dtype=tf.float32)
model = tf_model.signatures["serving_default"]
y = model(x)
sess.run(tf.global_variables_initializer())
output = sess.run(y["output"])
else:
tf_model = tf.saved_model.load(str(model_assets))
x = tf.convert_to_tensor(test_input, dtype=tf.float32)
model = tf_model.signatures["serving_default"]
y = model(x)
output = y["output"].numpy()
return output
def _get_weights_and_model_metadata(outdir, model, test_input, test_input_axes, test_input_norm_axes, mode, min_percentile, max_percentile):
# get the path to the exported model assets (saved in outdir)
if mode == "keras_hdf5":
raise NotImplementedError("Export to keras format is not supported yet")
elif mode == "tensorflow_saved_model_bundle":
assets_uri = outdir / "TF_SavedModel.zip"
model_csbdeep = model.export_TF(assets_uri, single_output=True, upsample_grid=True)
else:
raise ValueError(f"Unsupported mode: {mode}")
# to force "inputs.data_type: float32" in the spec (bonus: disables normalization warning in model._predict_setup)
test_input = test_input.astype(np.float32)
# convert test_input to axes_net semantics and shape, also resize if necessary (to adhere to axes_net_div_by)
test_input, axes_img, axes_net, axes_net_div_by, *_ = model._predict_setup(
img=test_input,
axes=test_input_axes,
normalizer=None,
n_tiles=None,
show_tile_progress=False,
predict_kwargs={},
)
# normalization axes string and numeric indices
axes_norm = set(axes_net).intersection(set(axes_check_and_normalize(test_input_norm_axes, disallowed='S')))
axes_norm = "".join(a for a in axes_net if a in axes_norm) # preserve order of axes_net
axes_norm_num = tuple(axes_net.index(a) for a in axes_norm)
# normalize input image
test_input_norm = normalize(test_input, pmin=min_percentile, pmax=max_percentile, axis=axes_norm_num)
net_axes_in = axes_net.lower()
net_axes_out = axes_check_and_normalize(model._axes_out).lower()
ndim_tensor = len(net_axes_out) + 1
input_min_shape = list(axes_net_div_by)
input_min_shape[axes_net.index('C')] = model.config.n_channel_in
input_step = list(axes_net_div_by)
input_step[axes_net.index('C')] = 0
# add the batch axis to shape and step
input_min_shape = [1] + input_min_shape
input_step = [0] + input_step
# the axes strings in bioimageio convention
input_axes = "b" + net_axes_in.lower()
output_axes = "b" + net_axes_out.lower()
if mode == "keras_hdf5":
output_names = ("prob", "dist") + (("class_prob",) if model._is_multiclass() else ())
output_n_channels = (1, model.config.n_rays,) + ((1,) if model._is_multiclass() else ())
# the output shape is computed from the input shape using
# output_shape[i] = output_scale[i] * input_shape[i] + 2 * output_offset[i]
output_scale = [1]+list(1/g for g in model.config.grid) + [0]
output_offset = [0]*(ndim_tensor)
elif mode == "tensorflow_saved_model_bundle":
if model._is_multiclass():
raise NotImplementedError("Tensorflow SavedModel not supported for multiclass models yet")
# regarding input/output names: https://github.com/CSBDeep/CSBDeep/blob/b0d2f5f344ebe65a9b4c3007f4567fe74268c813/csbdeep/utils/tf.py#L193-L194
input_names = ["input"]
output_names = ["output"]
output_n_channels = (1 + model.config.n_rays,)
# the output shape is computed from the input shape using
# output_shape[i] = output_scale[i] * input_shape[i] + 2 * output_offset[i]
# same shape as input except for the channel dimension
output_scale = [1]*(ndim_tensor)
output_scale[output_axes.index("c")] = 0
# no offset, except for the input axes, where it is output channel / 2
output_offset = [0.0]*(ndim_tensor)
output_offset[output_axes.index("c")] = output_n_channels[0] / 2.0
assert all(s in (0, 1) for s in output_scale), "halo computation assumption violated"
halo = model._axes_tile_overlap(output_axes.replace('b', 's'))
halo = [int(np.ceil(v/8)*8) for v in halo] # optional: round up to be divisible by 8
# the output shape needs to be valid after cropping the halo, so we add the halo to the input min shape
input_min_shape = [ms + 2 * ha for ms, ha in zip(input_min_shape, halo)]
# make sure the input min shape is still divisible by the min axis divisor
input_min_shape = input_min_shape[:1] + [ms + (-ms % div_by) for ms, div_by in zip(input_min_shape[1:], axes_net_div_by)]
assert all(ms % div_by == 0 for ms, div_by in zip(input_min_shape[1:], axes_net_div_by))
metadata, *_ = _import()
package_data = metadata("stardist")
is_2D = model.config.n_dim == 2
weights_file = outdir / "stardist_weights.h5"
model.keras_model.save_weights(str(weights_file))
config = dict(
stardist=dict(
python_version=package_data["Version"],
thresholds=dict(model.thresholds._asdict()),
weights=weights_file.name,
config=vars(model.config),
)
)
if is_2D:
macro_file = outdir / "stardist_postprocessing.ijm"
with open(str(macro_file), 'w', encoding='utf-8') as f:
f.write(DEEPIMAGEJ_MACRO.format(probThresh=model.thresholds.prob, nmsThresh=model.thresholds.nms))
config['stardist'].update(postprocessing_macro=macro_file.name)
n_inputs = len(input_names)
assert n_inputs == 1
input_config = dict(
input_names=input_names,
input_min_shape=[input_min_shape],
input_step=[input_step],
input_axes=[input_axes],
input_data_range=[["-inf", "inf"]],
preprocessing=[[dict(
name="scale_range",
kwargs=dict(
mode="per_sample",
axes=axes_norm.lower(),
min_percentile=min_percentile,
max_percentile=max_percentile,
))]]
)
n_outputs = len(output_names)
output_config = dict(
output_names=output_names,
output_data_range=[["-inf", "inf"]] * n_outputs,
output_axes=[output_axes] * n_outputs,
output_reference=[input_names[0]] * n_outputs,
output_scale=[output_scale] * n_outputs,
output_offset=[output_offset] * n_outputs,
halo=[halo] * n_outputs
)
in_path = outdir / "test_input.npy"
np.save(in_path, test_input[np.newaxis])
if mode == "tensorflow_saved_model_bundle":
test_outputs = _predict_tf(assets_uri, test_input_norm[np.newaxis])
else:
test_outputs = model.predict(test_input_norm)
# out_paths = []
# for i, out in enumerate(test_outputs):
# p = outdir / f"test_output{i}.npy"
# np.save(p, out)
# out_paths.append(p)
assert n_outputs == 1
out_paths = [outdir / "test_output.npy"]
np.save(out_paths[0], test_outputs)
from tensorflow import __version__ as tf_version
data = dict(weight_uri=assets_uri, test_inputs=[in_path], test_outputs=out_paths,
config=config, tensorflow_version=tf_version)
data.update(input_config)
data.update(output_config)
_files = [str(weights_file)]
if is_2D:
_files.append(str(macro_file))
data.update(attachments=dict(files=_files))
return data
def export_bioimageio(
model,
outpath,
test_input,
test_input_axes=None,
test_input_norm_axes='ZYX',
name=None,
mode="tensorflow_saved_model_bundle",
min_percentile=1.0,
max_percentile=99.8,
overwrite_spec_kwargs=None,
generate_default_deps=False,
):
"""Export stardist model into bioimage.io format, https://github.com/bioimage-io/spec-bioimage-io.
Parameters
----------
model: StarDist2D, StarDist3D
the model to convert
outpath: str, Path
where to save the model
test_input: np.ndarray
input image for generating test data
test_input_axes: str or None
the axes of the test input, for example 'YX' for a 2d image or 'ZYX' for a 3d volume
using None assumes that axes of test_input are the same as those of model
test_input_norm_axes: str
the axes of the test input which will be jointly normalized, for example 'ZYX' for all spatial dimensions ('Z' ignored for 2D input)
use 'ZYXC' to also jointly normalize channels (e.g. for RGB input images)
name: str
the name of this model (default: None)
if None, uses the (folder) name of the model (i.e. `model.name`)
mode: str
the export type for this model (default: "tensorflow_saved_model_bundle")
min_percentile: float
min percentile to be used for image normalization (default: 1.0)
max_percentile: float
max percentile to be used for image normalization (default: 99.8)
overwrite_spec_kwargs: dict or None
spec keywords that should be overloaded (default: None)
generate_default_deps: bool
not required for bioimage.io, i.e. StarDist models don't need a dependencies field in rdf.yaml (default: False)
if True, generate an environment.yaml file recording the python, bioimageio.core, stardist and tensorflow requirements
from which a conda environment can be recreated to run this export
"""
_, build_model, *_ = _import()
from .models import StarDist2D, StarDist3D
isinstance(model, (StarDist2D, StarDist3D)) or _raise(ValueError("not a valid model"))
0 <= min_percentile < max_percentile <= 100 or _raise(ValueError("invalid percentile values"))
if name is None:
name = model.name
name = str(name)
outpath = Path(outpath)
if outpath.suffix == "":
outdir = outpath
zip_path = outdir / f"{name}.zip"
elif outpath.suffix == ".zip":
outdir = outpath.parent
zip_path = outpath
else:
raise ValueError(f"outpath has to be a folder or zip file, got {outpath}")
outdir.mkdir(exist_ok=True, parents=True)
with tempfile.TemporaryDirectory() as _tmp_dir:
tmp_dir = Path(_tmp_dir)
kwargs = _get_stardist_metadata(tmp_dir, model, generate_default_deps)
model_kwargs = _get_weights_and_model_metadata(tmp_dir, model, test_input, test_input_axes, test_input_norm_axes, mode,
min_percentile=min_percentile, max_percentile=max_percentile)
kwargs.update(model_kwargs)
if overwrite_spec_kwargs is not None:
kwargs.update(overwrite_spec_kwargs)
build_model(name=name, output_path=zip_path, add_deepimagej_config=(model.config.n_dim==2), root=tmp_dir, **kwargs)
print(f"\nbioimage.io model with name '{name}' exported to '{zip_path}'")
def import_bioimageio(source, outpath):
"""Import stardist model from bioimage.io format, https://github.com/bioimage-io/spec-bioimage-io.
Load a model in bioimage.io format from the given `source` (e.g. path to zip file, URL)
and convert it to a regular stardist model, which will be saved in the folder `outpath`.
Parameters
----------
source: str, Path
bioimage.io resource (e.g. path, URL)
outpath: str, Path
folder to save the stardist model (must not exist previously)
Returns
-------
StarDist2D or StarDist3D
stardist model loaded from `outpath`
"""
import shutil, uuid
from csbdeep.utils import save_json
from .models import StarDist2D, StarDist3D
*_, bioimageio_core, _ = _import()
outpath = Path(outpath)
not outpath.exists() or _raise(FileExistsError(f"'{outpath}' already exists"))
with tempfile.TemporaryDirectory() as _tmp_dir:
tmp_dir = Path(_tmp_dir)
# download the full model content to a temporary folder
zip_path = tmp_dir / f"{str(uuid.uuid4())}.zip"
bioimageio_core.export_resource_package(source, output_path=zip_path)
with ZipFile(zip_path, "r") as zip_ref:
zip_ref.extractall(tmp_dir)
zip_path.unlink()
rdf_path = tmp_dir / "rdf.yaml"
biomodel = bioimageio_core.load_resource_description(rdf_path)
# read the stardist specific content
'stardist' in biomodel.config or _raise(RuntimeError("bioimage.io model not compatible"))
config = biomodel.config['stardist']['config']
thresholds = biomodel.config['stardist']['thresholds']
weights = biomodel.config['stardist']['weights']
# make sure that the keras weights are in the attachments
weights_file = None
for f in biomodel.attachments.files:
if f.name == weights and f.exists():
weights_file = f
break
weights_file is not None or _raise(FileNotFoundError(f"couldn't find weights file '{weights}'"))
# save the config and threshold to json, and weights to hdf5 to enable loading as stardist model
# copy bioimageio files to separate sub-folder
outpath.mkdir(parents=True)
save_json(config, str(outpath / 'config.json'))
save_json(thresholds, str(outpath / 'thresholds.json'))
shutil.copy(str(weights_file), str(outpath / "weights_bioimageio.h5"))
shutil.copytree(str(tmp_dir), str(outpath / "bioimageio"))
model_class = (StarDist2D if config['n_dim'] == 2 else StarDist3D)
model = model_class(None, outpath.name, basedir=str(outpath.parent))
return model

bioimageio_utils.py at commit e80c6de, under BSD-3-Clause · at the source

Overview

Authors: Muxin Lin^1,2, Thu-Huong Hoang², Denise Manahan-Vaughan^1,2

Institutions: Ruhr University Bochum (Germany)

Journal: Frontiers in behavioral neuroscience, volume 20, article 1895371

Dates: received 30 May 2026; accepted 6 July 2026; published online 7 August 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.3389/fnbeh.2026.1895371 · PMID 42630415 · PMCID PMC13493596 · OpenAlex W7196949817

Open access: gold, a free copy (OpenAlex)

Status: code verified

Categories: histology / microscopy (modality), rat (organism)

Methods: Statistics, Spectral & time-frequency, fMRI & imaging

Keywords: dorsoventral, fluorescence in situ hybridization, hippocampus, immediate early gene, rat, spatial learning

Topic: Memory and Neural Mechanisms (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Citations: not cited yet (Europe PMC); 183 references in the paper

Abstract

A multitude of studies have confirmed the essential role of the hippocampus in the acquisition and updating of associative experience. In rodents, spatial memories are dependent on hippocampal information processing and encoding. The role of the dorsal hippocampal pole is well documented, but information about the roles of the intermediate and ventral hippocampus in spatial learning are few and often contradictory. Here, we used fluorescence in situ hybridization (FISH) to identify nuclear expression of the immediate early (IEG) gene, Homer1a, that was triggered by specific spatial learning events in hippocampal neurons of adult male rats. We compared IEG expression in the cornu ammonis (CA) and dentate gyrus (DG) along the proximodistal and dorsoventral hippocampal axis, triggered by novel learning about spatial constellations of large (macroscale), or partially concealed (microscale) objects within a familiar environment. We observed that the dorsal hippocampus predominates with regard to the neuronal encoding of both forms of spatial content information, whereby the distal CA1 (dCA1) and proximal CA3 (pCA3) preferentially encode microscale spatial location. The infrapyramidal blade of the DG, as well as pCA3, encode macroscale information. The intermediate CA shows increased IEG expression in dCA1 triggered by novel microscale information, but the DG of neither the intermediate, nor ventral, hippocampus encode macroscale information. The ventral hippocampus exhibits IEG expression patterns that are unique in comparison to the other two structures: here, both CA1 (proximal and distal) and pCA3 encode macroscale information. Taken together, these findings suggest that the intermediate and ventral hippocampus support spatial memory encoding, but may do so in support of differentiated and distinct aspects of associative learning.

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

Repository

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

stardist/stardist

License: BSD-3-Clause

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: e80c6de700693bc228ed3c9ba1dc19c3785667ee, 14 February 2026

Languages: Python (40), C/C++ (38), C++ (26), C (15), Jupyter (14)

Size: 201 files, 133 scripts

Software Heritage: archived

Found in: the text

Holds: README, license file, environment (pyproject.toml, setup.cfg, setup.py, docker/Dockerfile), tests, continuous integration, 14 notebooks

Not found: CITATION.cff, documentation

Tools: NumPy (19 files), Matplotlib (14 files), tifffile (14 files), scikit-image (7 files), imageio (2 files), Numba (1 file), SciPy (1 file), TensorFlow (1 file), xarray (1 file)

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

27 September 2026: the link answers

59 files

examples/2D/1_data.ipynb, Jupyter, 110 lines
examples/2D/2_training.ipynb, Jupyter, 293 lines
examples/2D/3_prediction.ipynb, Jupyter, 158 lines
examples/3D/1_data.ipynb, Jupyter, 137 lines
examples/3D/2_training.ipynb, Jupyter, 315 lines
examples/3D/3_prediction.ipynb, Jupyter, 138 lines
examples/other2D/1_data.ipynb, Jupyter, 161 lines
examples/other2D/2_training.ipynb, Jupyter, 190 lines
examples/other2D/3_prediction.ipynb, Jupyter, 155 lines
examples/other2D/bioimageio.ipynb, Jupyter, 97 lines
examples/other2D/export_imagej_rois.ipynb, Jupyter, 91 lines
examples/other2D/multiclass.ipynb, Jupyter, 383 lines
examples/other2D/predict_big_data.ipynb, Jupyter, 198 lines
extras/stardist_example_2D_colab.ipynb, Jupyter, 429 lines
setup.py, Python, 170 lines
stardist/__init__.py, Python, 30 lines
stardist/big.py, Python, 624 lines
stardist/bioimageio_utils.py, Python, 494 lines, 1 match
stardist/data/__init__.py, Python, 39 lines
stardist/geometry/__init__.py, Python, 10 lines
stardist/geometry/geom2d.py, Python, 215 lines
stardist/geometry/geom3d.py, Python, 349 lines
stardist/lib/external/clipper/clipper.cpp, C++, 4,629 lines
stardist/lib/external/qhull_src/src/libqhull_r/geom2_r.c, C, 2,268 lines
stardist/lib/external/qhull_src/src/libqhull_r/geom_r.c, C, 1,273 lines
stardist/lib/external/qhull_src/src/libqhull_r/geom_r.h, C/C++, 189 lines
stardist/lib/external/qhull_src/src/libqhull_r/global_r.c, C, 2,129 lines
stardist/lib/external/qhull_src/src/libqhull_r/io_r.c, C, 4,115 lines
stardist/lib/external/qhull_src/src/libqhull_r/io_r.h, C/C++, 168 lines
stardist/lib/external/qhull_src/src/libqhull_r/libqhull_r.c, C, 1,654 lines
stardist/lib/external/qhull_src/src/libqhull_r/libqhull_r.h, C/C++, 1,188 lines
stardist/lib/external/qhull_src/src/libqhull_r/mem_r.c, C, 562 lines
stardist/lib/external/qhull_src/src/libqhull_r/mem_r.h, C/C++, 236 lines
stardist/lib/external/qhull_src/src/libqhull_r/merge_r.c, C, 5,165 lines
stardist/lib/external/qhull_src/src/libqhull_r/merge_r.h, C/C++, 251 lines
stardist/lib/external/qhull_src/src/libqhull_r/poly2_r.c, C, 3,699 lines
stardist/lib/external/qhull_src/src/libqhull_r/poly_r.c, C, 1,317 lines
stardist/lib/external/qhull_src/src/libqhull_r/poly_r.h, C/C++, 306 lines
stardist/lib/external/qhull_src/src/libqhull_r/qhull_ra.h, C/C++, 161 lines
stardist/lib/external/qhull_src/src/libqhull_r/qset_r.c, C, 1,340 lines
stardist/lib/external/qhull_src/src/libqhull_r/qset_r.h, C/C++, 504 lines
stardist/lib/external/qhull_src/src/libqhull_r/random_r.c, C, 248 lines
stardist/lib/external/qhull_src/src/libqhull_r/random_r.h, C/C++, 41 lines
stardist/lib/external/qhull_src/src/libqhull_r/rboxlib_r.c, C, 842 lines
stardist/lib/external/qhull_src/src/libqhull_r/stat_r.c, C, 683 lines
stardist/lib/external/qhull_src/src/libqhull_r/stat_r.h, C/C++, 533 lines
stardist/lib/external/qhull_src/src/libqhull_r/user_r.c, C, 535 lines
stardist/lib/external/qhull_src/src/libqhull_r/user_r.h, C/C++, 994 lines
stardist/lib/external/qhull_src/src/libqhullcpp/Coordinates.cpp, C++, 198 lines
stardist/lib/external/qhull_src/src/libqhullcpp/Coordinates.h, C/C++, 303 lines
stardist/lib/external/qhull_src/src/libqhullcpp/PointCoordinates.cpp, C++, 348 lines
stardist/lib/external/qhull_src/src/libqhullcpp/PointCoordinates.h, C/C++, 161 lines
stardist/lib/external/qhull_src/src/libqhullcpp/Qhull.cpp, C++, 352 lines
stardist/lib/external/qhull_src/src/libqhullcpp/Qhull.h, C/C++, 132 lines
stardist/lib/external/qhull_src/src/libqhullcpp/QhullError.h, C/C++, 62 lines
stardist/lib/external/qhull_src/src/libqhullcpp/QhullFacet.cpp, C++, 519 lines
stardist/lib/external/qhull_src/src/libqhullcpp/QhullFacet.h, C/C++, 151 lines
repository limit reached (2,000 files or 30 MB): the rest is at the source (76 files)
LICENSE.txt, License, 29 lines
README.md, Text, 334 lines

At the source: github.com/stardist/stardist

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:

1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
57 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 statement

The raw data supporting the conclusions of this article will be made available by the authors, upon reasonable request.

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, 3 authors, 6 keywords, 181 references.

Cite

This paper

Lin, M., Hoang, T.-H., & Manahan-Vaughan, D. (2026). Discrete and differentiated encoding of distinct components of spatial experience occurs within the proximodistal subfields of the dorsoventral axis of the hippocampus. Frontiers in behavioral neuroscience, 20, 1895371. https://doi.org/10.3389/fnbeh.2026.1895371

BibTeX

@article{lin2026discrete, author = {Lin, Muxin and Hoang, Thu-Huong and Manahan-Vaughan, Denise}, title = {{Discrete and differentiated encoding of distinct components of spatial experience occurs within the proximodistal subfields of the dorsoventral axis of the hippocampus}}, journal = {Frontiers in behavioral neuroscience}, year = {2026}, month = aug, volume = {20}, pages = {1895371}, publisher = {Frontiers Media SA}, issn = {1662-5153}, doi = {10.3389/fnbeh.2026.1895371}, url = {https://doi.org/10.3389/fnbeh.2026.1895371}, pmid = {42630415}, pmcid = {PMC13493596} }

RIS

TY - JOUR AU - Lin, Muxin AU - Hoang, Thu-Huong AU - Manahan-Vaughan, Denise TI - Discrete and differentiated encoding of distinct components of spatial experience occurs within the proximodistal subfields of the dorsoventral axis of the hippocampus T2 - Frontiers in behavioral neuroscience J2 - Front Behav Neurosci PY - 2026 DA - 2026/08/07 VL - 20 SP - 1895371 SN - 1662-5153 PB - Frontiers Media SA DO - 10.3389/fnbeh.2026.1895371 UR - https://doi.org/10.3389/fnbeh.2026.1895371 LA - en ER -

CSL-JSON

{ "id": "10.3389/fnbeh.2026.1895371", "type": "article-journal", "title": "Discrete and differentiated encoding of distinct components of spatial experience occurs within the proximodistal subfields of the dorsoventral axis of the hippocampus", "container-title": "Frontiers in behavioral neuroscience", "author": [ { "family": "Lin", "given": "Muxin" }, { "family": "Hoang", "given": "Thu-Huong" }, { "family": "Manahan-Vaughan", "given": "Denise" } ], "container-title-short": "Front Behav Neurosci", "volume": "20", "page": "1895371", "DOI": "10.3389/fnbeh.2026.1895371", "PMID": "42630415", "PMCID": "PMC13493596", "ISSN": "1662-5153", "publisher": "Frontiers Media SA", "URL": "https://doi.org/10.3389/fnbeh.2026.1895371", "language": "en", "issued": { "date-parts": [ [ 2026, 8, 7 ] ] } }

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

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1371/journal.pcbi.1013488 [code]: Evaluating place cell detection methods in Rats and Humans: Implications for cross-species spatial coding.
Journal: PLoS computational biology
In common: SciPy, Matplotlib, NumPy, rat, 8 references
[2] doi:10.1016/j.isci.2026.116213 [code]: Opioid receptor distribution in the claustrum-dorsal endopiriform complex.
Journal: iScience
In common: xarray, imageio, tifffile, 6 other tools, 1 reference
[3] doi:10.1016/j.isci.2026.115689 [code]: Unperturbed dye-based imaging of spontaneous synchronized calcium activity in iPSC-derived neuronal cultures.
Journal: iScience
In common: xarray, imageio, tifffile, 6 other tools
[4] doi:10.1523/jneurosci.2001-25.2026 [code]: Dynamics of Dentate Gyrus Place Cells and Dentate Spikes during Spatial and Nonspatial Changes in Environments.
Journal: The Journal of neuroscience : the official journal of the Society for Neuroscience
In common: Numba, SciPy, Matplotlib, 1 other tool, rat, 5 references
[5] doi:10.3389/fcogn.2026.1767179 [code]: Adult lifespan effects on functional specialization along the hippocampal long axis.
Journal: Frontiers in cognition
In common: Matplotlib, NumPy, 7 references
[6] doi:10.1038/s41593-026-02388-9 [code]: Hippocampal CA3 connectomics reveals a gradient of mossy fiber inputs and selective feedforward inhibition onto pyramidal cells.
Journal: Nature neuroscience
In common: imageio, SciPy, Matplotlib, 1 other tool, histology / microscopy, 4 references
[7] doi:10.7554/elife.109717 [code]: Retrosplenial cortex enables context-dependent goal-directed sensorimotor transformation.
Journal: eLife
In common: imageio, tifffile, Numba, 4 other tools, 1 reference
[8] doi: [code]: Real-time closed-loop feedback system for mouse mesoscale cortical signal and movement control
Journal: eLife
In common: imageio, tifffile, Numba, 5 other tools
[9] doi:10.1371/journal.pcbi.1014571 [code]: SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: imageio, tifffile, Numba, 5 other tools
[10] doi:10.1016/j.xcrm.2026.102766 [code]: A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: imageio, tifffile, Numba, 5 other tools

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.

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: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

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