A typical pipeline reads left to right: a dataset, a query against it, a transform or two, and a viewer at the end. Click on any node to see its sockets, its settings and what its card looks like on the canvas.
The legend below illustrates the most important elements you will find on a node.
Hover a label to see a short description.
Tells you whether the card’s result is up to date. Each state has its own symbol as well as a colour, so you don’t have to tell the colours apart. The stripe down the left edge shows the same state.
Double-click to rename the node. The new name is saved with the workflow but the node’s type stays the same.
Hides the settings and socket rows to make room for whatever the card draws. Wires stay connected: the sockets move up into the header.
Collapses the whole card down to its header. Unlike ☰, this also hides the drawing and everything else below the header.
The header colour shows the node’s category, e.g. green for datasets and blue for queries. The stripe down the left edge shows the run state, which you can still see when zoomed too far out to read the badge.
Attach your own edge list with pre, post and weight columns. Connectivity queries downstream of this card will then use your file instead of the server.
How long ago this dataset’s neuron table was downloaded. We keep it for a month. Click to throw it away and fetch it again.
Messages from the node. Amber is a warning and the result is still usable; red is an error and there is no result. The inspector lists all of them.
Colour, shape and socket label all tell you the type, here a Dataset. You can only connect sockets whose types match: while you drag a wire, the sockets it can’t connect to are dimmed.
Runs this node plus any outdated nodes it depends on, but not the rest of the graph. The button is disabled when the result is up to date and turns into ■ while the node is running.
Opens the result full size on top of the canvas. You can also double-click the drawing on the card.
Docks the result next to the canvas so you can keep looking at it while you work on other cards. Only one node can be pinned at a time.
Opens the help page for this node. Only shown for node types that have one.
Where data comes in. Each socket accepts one type of value. If a required input isn’t connected, the card will tell you it has nothing to work on.
Where results go out. A node can have several outputs, so pick the one you want downstream. Hover over a socket to preview its value.
Settings that are only shown in the inspector, not on the card. Click to select the node and open the inspector. If you have changed any of them, the line also says how many.
+ page selects the neurons on this page and + all selects every match. Click the count to clear the selection. Selected neurons come out of the Selected port and are saved with the workflow.
Nothing matches . Try a socket type such as matrix or skeletons, or a setting like hops.
The same 147 nodes as the grid above, written out on one page and grouped in pipeline order. You can read it top to bottom or search it with your browser's find. Each entry lists the node's inputs and outputs, and whether it runs as you edit or waits for you to press Run.
Where the data comes from: the published connectomes, your own deployments and annotation tables.
dataset.bancAnnotations? → Datasetruns as you edit
Brain and ventral nerve cord of an adult female fly.
The public BANC (brain and nerve cord) connectome, read through CAVE. The version is a materialization number, and the neuron table is the public cell list published with the datastack.
annotation.caveTableDataset?, Annotations? → Annotationswaits for Run
Neuron labels from an annotation table in a CAVE datastack. A `cell_type` column arrives renamed `type`, which is the column Coda reads cell types from.
Reads an annotation table from a CAVE datastack and passes it to a Dataset as neuron labels. Wire the Dataset into its Dataset input (or type the datastack) and name the table; for a long table with one row per neuron and kind of annotation, set Pivot on.
cave.tableInfoDataset? → Columnswaits for Run
Describes one CAVE table or view: its description, its row counts, and its columns as a table with `column`, `type` and `example`.
Shows what one table of a CAVE datastack holds: its schema, the description its publisher wrote, two row counts (the card explains the difference) and the columns a query returns, sampled from one row, so pt arrives as pt_position_x/y/z, pt_supervoxel_id and pt_root_id. Views work too, but an aggregating view is slow to sample and the node warns first.
dataset.catmaid→ Datasetruns as you edit
Any CATMAID project, configured by hand.
Connects to a CATMAID project that has no node of its own, e.g. on a lab server. Type the server URL and pick the project from the list the server returns (project ids differ between servers). Public servers need no credentials; for one behind a login, add the host under Connections ▸ CATMAID first.
dataset.caveAnnotations? → Datasetruns as you edit
Any CAVE datastack, configured by hand.
Connects to any CAVE datastack Coda has no dedicated node for. Name the global server (H01 is on global.brain-wire-test.org), the datastack and, optionally, a table with one row per neuron and its root-id column. Wire labels in through Annotations, e.g. from a CAVE table.
connectome:customDatasetNeurons?, Edges?, Synapses?, Meshes?, Skeletons? → Datasetruns as you edit
Assemble a dataset from your own parts: a neuron table, an edge list, a synapse table, and meshes or skeletons from other datasets.
Builds a dataset from your own parts: a neuron table, an edge list and/or a synapse table (as tables or Link Table files), plus meshes and skeletons from any other dataset. Wire only what you have; downstream nodes like Find Neurons or Connectivity treat the result like any other dataset. The ids must refer to the same neurons in every part.
dataset.neuprint→ Datasetruns as you edit
Any neuPrint dataset, configured by hand.
Connects to a neuPrint dataset that has no node of its own: a release newer than this build, a private dataset, or another neuPrint server. Type the server and the dataset id exactly as the server names it, version included. Server is a neuPrint deployment and is a separate setting from the Base URL override under Connections.
dataset.mock.opticlobe→ Datasetruns as you edit
A synthetic optic-lobe-like connectome generated in the browser. Needs no token.
A synthetic optic lobe with the columnar structure of a real one, generated in the browser from a fixed seed. Nothing is fetched and no token is needed, and a workflow gives the same answer on any machine. The Workflow Wizard’s demo workflows and the guided tours run on it, and it is a good place to try a pipeline before running it on real data.
dataset.descriptionDataset →runs as you edit
The text a dataset’s publisher wrote about it: what it covers, who made it and how to cite it.
Shows the description a dataset’s publisher provides, e.g. neuPrint’s text naming the project, its viewers and the papers to cite. It is added and wired below every new dataset node. If you delete it, it stays deleted; Add ▸ Dataset ▸ Description brings it back.
dataset.catmaid.fafb→ Datasetruns as you edit
Early manual reconstructions in an adult female fly brain. Published data hosted by Virtual Fly Brain.
A few thousand neurons traced by hand in CATMAID on the same image volume as FlyWire, with skeletons, synapses, connectivity and free-text annotations. Hosted by Virtual Fly Brain at https://catmaid-fafb.virtualflybrain.org/; no credentials needed.
dataset.fib19→ Datasetruns as you edit
Partial reconstruction of a female fly’s visual system: parts of the medulla, lobula and lobula plate.
A partial reconstruction of the medulla, lobula and lobula plate of a female fly, read from neuPrint. It was made to map the circuits of the visual motion detection pathway.
annotation.flyTableAnnotations? → Annotationswaits for Run
Neuron labels from a table in a FlyTable base. A `cell_type` column arrives renamed `type`, which is the column Coda reads cell types from.
Reads a table from FlyTable, the LMB’s SeaTable deployment used for FlyWire cell typing, and passes it to a Dataset as neuron labels. Needs a FlyTable account token. The table is cached in the browser; click the cache indicator on the card to fetch it again.
dataset.flywireAnnotations? → Datasetruns as you edit
Whole brain of an adult female fly: central brain and both optic lobes.
The public FlyWire whole-brain connectome, read through CAVE; the version is a materialization number. Meshes, synapses and connectivity work, skeletons only on materialization 783. The built-in cell types are outdated, so use the Use current annotations button on the card to wire in the current ones.
annotation.googleSheetAnnotations? → Annotationswaits for Run
Neuron labels from a Google Sheet shared by link, read through its CSV export. A `cell_type` column arrives renamed `type`, which is the column Coda reads cell types from.
Reads a tab of a Google Sheet and passes it to a Dataset as neuron labels. Share the sheet as "Anyone with the link" (Viewer) and paste its link into Sheet; to read a different tab, set Tab to its numeric gid.
dataset.hemibrain→ Datasetruns as you edit
Approximately one hemisphere of the central brain of an adult female fly.
Approximately one hemisphere of the central brain of an adult female fly, plus parts of the right optic lobe, read from neuPrint. Comes with rich annotations (cell type, class, cell body fibre, hemilineage and more); some neurons are truncated at the edges of the volume.
dataset.catmaid.l1→ Datasetruns as you edit
Central nervous system of a first-instar fly larva, with the brain densely reconstructed and the rest sparsely. Published data hosted by Virtual Fly Brain.
The larval connectome: 5,013 hand-traced neurons across the whole first-instar central nervous system, hosted by Virtual Fly Brain at https://l1em.catmaid.virtualflybrain.org/. A neuron’s type is its own name, and its many annotations (lineages, clusters, papers) show up as tags.
cave.tablesDataset? → Tableswaits for Run
Lists every annotation table and view a CAVE datastack publishes, as a table with `table` and `kind` columns.
Lists the tables and views of a CAVE datastack by name, with a kind column saying which is which. Use it to find the names to give CAVE table or CAVE table info. Views are often the useful ones: FlyWire’s connectivity, for example, is only in the valid_connection_v2 view.
dataset.malecns→ Datasetruns as you edit
Whole central nervous system of an adult male fly: brain and ventral nerve cord.
The central nervous system of an adult male fly, brain and ventral nerve cord, read from neuPrint. With 167k proofread neurons it is the largest fly connectome published so far, so a circuit can be followed from sensory neurons all the way to the motor neurons that drive the muscles.
dataset.manc→ Datasetruns as you edit
Ventral nerve cord of an adult male fly.
The male adult nerve cord (MANC), read from neuPrint. It contains the motor neurons, the premotor circuits that drive them, and the descending neurons that arrive from the brain.
dataset.minnie65Annotations? → Datasetruns as you edit
Public volume of mouse visual cortex from the MICrONS collaboration.
The public MICrONS Minnie65 volume of mouse visual cortex, read through CAVE. The version is a materialization number, and the neuron table is the cell list published with the datastack.
dataset.mushroombody→ Datasetruns as you edit
Reconstruction of the alpha lobe of the mushroom body of a male fly.
A dense reconstruction of the alpha (vertical) lobe of the mushroom body of a male Drosophila, read from neuPrint. One of the earliest fly connectomes, with 983 neurons.
dataset.ngsourceLayers? → Datasource, Layersruns as you edit
Reads meshes, skeletons or region shells from a neuroglancer precomputed URL, and makes it a layer for the Neuroglancer node.
Reads one neuroglancer source (the URL in a layer’s Source box). The Datasource output feeds Meshes, Skeletons and ROI Meshes; without segment properties, take the ids from Input IDs. The Layers output goes into the Neuroglancer node’s Extra layers socket; chain several of these nodes to add more than one layer.
dataset.opticlobe→ Datasetruns as you edit
The right optic lobe of a male fly: medulla, lobula and lobula plate, with parts of the lamina and the central brain.
The right optic lobe of the MaleCNS volume (medulla, lobula and lobula plate, with parts of the lamina and the central brain), released before the full dataset. It is mainly kept for reproducing the papers that used it; for new work use MaleCNS.
annotation.seaTableAnnotations? → Annotationswaits for Run
Neuron labels from a table in a SeaTable base. A `cell_type` column arrives renamed `type`, which is the column Coda reads cell types from.
Reads a table from one of your bases on cloud.seatable.io and passes it to a Dataset as neuron labels. Needs a SeaTable account token, separate from a FlyTable one. Use FlyTable instead for the LMB’s own deployment.
Ask a dataset a question. Most of these fetch from a server, so they wait for you to press Run.
neuron.adjacencyDataset, Sources, Targets → Matrix, Linkswaits for Run
Synapse counts from one set of neurons onto another, as a matrix and as an edge list with Connectivity’s columns: `preId`, `preType`, `postId`, `postType` and `weight`.
Counts synapses from the Sources onto the Targets, per cell type or per neuron. The matrix goes into a Heatmap (via Normalize if one type dominates). Links has one row per non-zero cell in the same columns as Connectivity’s edge list, so it feeds the same nodes; grouped by type, the id columns are empty and the types name each end.
annotation:bigclust→ Neurons, Embedding, Neighbours, Features, Scenewaits for Run
Read one embedding of a BigClust project: its neurons, their coordinates, the k-NN graph and the feature vectors.
Reads one embedding from a BigClust project, at a URL or on your disk: the neurons, their x/y coordinates and, where the project has them, the k-NN graph and feature vectors. Plot the coordinates with a Scatter Plot, or wire the Scene output into a Neuroglancer node to see the neurons in 3D.
connectome:connectionCompartmentsDataset, Edges, Skeletons → Edges, Synapseswaits for Run
Count each edge’s synapses by the compartment at either end: axo-dendritic, axo-axonic, dendro-axonic, dendro-dendritic, linker or unsplit.
Takes an edge list and skeletons split by Split Axon/Dendrite, fetches every synapse between the listed pairs, and counts each edge’s synapses by the compartment at the presynaptic and the postsynaptic end. Each end is placed on its own neuron’s skeleton at its own site. A synapse that cannot be placed is counted as unsplit, so the counts of an edge always add up to its synapses.
neuron.connectivityDataset, Neurons → Connections, Neuron Setwaits for Run
Fetch the synaptic partners of the incoming neurons, one or more hops out. Rows are `preId`, `preType`, `postId`, `postType`, `weight`, `hop` and `direction`; a region split adds `roi`, and `Normalize` adds `weightNorm` and `weightTotal`.
Fetches the synaptic partners of a set of neurons, one or more hops up- or downstream. Connections is an edge list (preId → postId) that goes straight into Build Network; Neuron Set lists the queried neurons plus every partner found, e.g. for Adjacency. Fragments are left out unless you tick Include fragments.
cortex:galleryDataset → Selected, Skeletonswaits for Run
Neurons side by side at their cortical depth, with the layers behind them and axon and dendrite in two colours.
Draws a wall of reconstructed cells, each at its depth below the pia, with the layers behind them and axon and dendrite in two colours. Browse by cell type and proofreading status, then select cells to pass them on as a table (with soma depth and layer) and as skeletons.
neuron.rawCypherDataset → Resultwaits for Run
Runs a Cypher query you write against a neuPrint dataset and returns the result as a table.
Runs a Cypher query you write yourself against a neuPrint dataset and returns the result as a table. Column pickers downstream stay empty until the query has run, and again after a reload. The servers are shared and only accept read-only queries.
neuron.exploreDataset → Hits, Selected, Allwaits for Run
Browse every neuron in a dataset, with fuzzy search across all fields, per-field filters and a picker. Outputs the search hits, the ticked neurons and the whole table.
Browse and search every neuron in a dataset. The neuron table is downloaded once and then searched locally as you type. Wire a dataset in; Hits gives the search results, Selected the neurons you ticked, and All the whole table.
neuron.findNeuronsDataset → Neuronswaits for Run
Searches a dataset for neurons by any field the dataset publishes.
Searches a dataset for neurons using one or more filter rows (field, condition, value), e.g. type matches LC.*. Rows are combined with AND; use “is one of” for OR. A node without filters returns no neurons. The result feeds most other neuron nodes.
neuron.idsFromLabelDataset, Labels? → Neuronswaits for Run
Looks up the neurons that carry given cell types or other labels.
Looks up the neurons carrying a list of labels, e.g. all neurons of a few cell types: the inverse of Find Neurons. Type the labels or wire in a table column. Matching is exact by default, so names like SMP001(a) can be pasted as they are.
neuron.influenceDataset, Neurons, Candidates? → Influence, Transferswaits for Run
Score every neuron by how strongly it drives, or is driven by, a set of query neurons. Columns are `influence`, `influenceLog`, `hops` and `isSeed`; scoring per query adds `queryId` and `queryType`.
Scores neurons by how strongly they drive (or are driven by) a set of query neurons, summed over all paths up to Max hops, following Bates et al. Wire neurons in from Find Neurons and get every neuron reached back, ranked. Scores are lower bounds on the exact ones, and the node reports how much was left out.
neuron.inputIdsDataset?, IDs? → Neuronswaits for Run
Turns a typed or pasted list of neuron IDs into a neuron table.
Turns a list of neuron IDs you already have (from a paper, a spreadsheet or Neuroglancer) into a neuron table. Paste them in almost any format. Wire a Dataset to fetch the full neuron rows and find IDs that do not exist; without one, you get a one-column table.
neuron.meshesDataset, Neurons → Mesheswaits for Run
Fetches surface meshes for the incoming neurons.
Fetches surface meshes for the incoming neurons, usually for a 3D View. Detail sets a triangle budget for the whole set where the source has several levels of detail; Downsample reduces the meshes on any source. Use Carry fields to bring along extra columns from the neuron table.
zapbench:neuronTracesNeurons → Matrixwaits for Run
Calcium-imaging traces from ZapBench, as a matrix, for the fish2 neurons that carry a `zapbenchId`.
Fetches the ZapBench calcium traces for the neurons in a fish2 table that have a zapbenchId, as a matrix for a Heatmap or Reduce Matrix. Reads are priced in 512-cell blocks (about 16 MiB each over the whole recording); pick a Condition to make them smaller.
neuron.pathsDataset, Sources, Targets → Network, Layout, Pathswaits for Run
Find the strongest routes from one set of neurons to another. The Paths table has `rank`, `source`, `target`, `hops`, `bottleneck` and `path`, plus `bottleneckNorm` when normalizing.
Finds the strongest routes from a set of source neurons to a set of target neurons, ranked by their weakest link. By default it searches between cell types rather than individual neurons. Wire Network and Layout into a Network Viewer, or use the Paths table for one row per route.
neuron.roiCompletenessDataset → Completenesswaits for Run
How completely each region of a dataset has been reconstructed: synapses on traced neurons against all synapses in the region.
Shows how completely each brain region of a neuPrint dataset has been reconstructed: the fraction of pre- and postsynapses that belong to traced neurons. Needs only a Dataset. By default only primary regions are returned, since the full list is nested.
neuron.roiConnectivityDataset → Matrix, Linkswaits for Run
Region-to-region connectivity across a whole dataset, as a matrix and as a table of region pairs.
Region-to-region connectivity for a whole neuPrint dataset, precomputed by neuPrint. Gives you a matrix for a Heatmap and a table of region pairs for everything else. Cells decides which of neuPrint’s two numbers (weight or count) fills the matrix.
neuron.roiCountsDataset, Neurons → Countswaits for Run
Pre- and postsynapse counts per region for the incoming neurons: one row per neuron and region, with `roi`, `pre` and `post` columns.
Counts the pre- and postsynapses of the incoming neurons in each brain region, as one row per neuron per region; summarise it with Group By or Pivot. Regions are nested, so adding up all rows counts each synapse several times.
neuron.roiMeshesDataset → Volumeswaits for Run
Fetches the 3D meshes of a dataset’s brain regions (neuropils) as Volumes.
Fetches the 3D meshes of a dataset’s brain regions (neuropils), so you can show neurons inside the regions they innervate. Wire the output into the 3D View’s Volumes input. Leave Regions empty to get the primary regions, which tile the brain without overlapping.
neuron.skeletonsDataset, Neurons → Skeletonswaits for Run
Fetches skeletons (centreline tracings) for the incoming neurons.
Fetches skeletons (centreline tracings) for the incoming neurons, in nanometres. Wire a Dataset and a table of neurons, and send the output to a 3D View, NBLAST or Distance between. Use Carry fields to bring along extra columns from the neuron table, e.g. to colour by.
neuron.synapsesDataset, Neurons → Pointswaits for Run
Fetch the synapses of a set of neurons as a 3D point cloud, one point per synapse, carrying `neuronId`, `polarity` and, where the source has one, `partnerId`.
Fetches the synapses of a set of neurons as a point cloud, with each synapse’s polarity and, where the data source has it, its partner. The points share a space with skeletons and meshes, so they can be drawn together in a 3D View. Backends count synapses differently, so Rows sets whether a point is one connection or one synaptic site.
neuron.synapsesBetweenDataset, Sources?, Targets? → Pointswaits for Run
Fetch the synapses from one set of neurons onto another as a 3D point cloud. Each point carries its source as `neuronId` and its target as `partnerId`.
Fetches every synapse from the Sources onto the Targets as a point cloud, one point per connection. Wire only Sources for everything they synapse onto, or only Targets for everything onto them. Location sets whether points sit at the pre- or postsynaptic site; counting points per pair, e.g. with Synapses to Edges, gives the Connectivity weight.
vfb:linesTypes → Lineswaits for Run
The driver lines Virtual Fly Brain records as labelling each cell type.
Lists the split-GAL4, GAL4 and LexA lines that Virtual Fly Brain records as labelling each FBbt cell type in a table, one row per type and line. Wire it after VFB Neurons. The `targets` column says how many cell types a line labels in all, so a line for your type alone reads 1; VFB Expression Images takes the lines on to their registered images.
vfb:imagesLines → Imageswaits for Run
The registered light-microscopy images of each driver line, with their files.
Lists the registered images Virtual Fly Brain holds for each driver line, one row per image, with its template, dataset, licence and file URLs. Wire it after VFB Driver Lines, and on to VFB Load Expression to draw the images in a 3D View. Only images registered to JRC2018U brain line up with EM neurons transformed to that space.
vfb:expressionImages → Pointswaits for Run
Load driver-line images as points, for a 3D View beside EM neurons.
Downloads each image’s point cloud from Virtual Fly Brain, so driver-line expression can be drawn in a 3D View. Wire it after VFB Expression Images. Images registered to JRC2018U brain land in Coda’s common space, so EM skeletons transformed to JRC2018U line up with them; each image is thinned to `Points per image`, since a single cloud can hold half a million points.
vfb:neuronsDataset, Neurons → Neuronswaits for Run
Look each neuron up in Virtual Fly Brain: its VFB id and its cell type as an FBbt term.
Adds four columns to a neuron table: the neuron’s Virtual Fly Brain id, its cell type as an FBbt term (`fbbtId`, `fbbtLabel`), and how far up the ontology that type was found. The FBbt term is what VFB Publications and the other VFB nodes read. VFB holds exact releases only, so a dataset version it does not hold is refused rather than matched to the nearest one.
vfb:publicationsTypes → Publicationswaits for Run
The papers Virtual Fly Brain cites for each cell type, with DOI and PubMed id.
Lists the papers Virtual Fly Brain cites for each FBbt cell type in a table, one row per type and paper, with the role the paper plays: defining the type, naming it, or a text-mined mention. Wire it after VFB Neurons. The papers describe the type, not any one neuron, which is why each row also counts how many of your neurons carry that type.
zapbench:neuronsDataset, Cells? → Neuronswaits for Run
The fish2 neurons matched to a set of ZapBench cells, taken from a Heatmap selection or a list of cell ids.
Looks up the fish2 neurons matching a set of ZapBench cells, e.g. for Skeletons or Meshes. Wire a Heatmap’s Selected Rows into Cells or type cell ids, and wire a fish2 Dataset. Cells without an EM neuron (about one in eight) are counted in a warning.
zapbench:traces→ Matrixwaits for Run
Activity of every ZapBench cell at a reduced scale, or of listed cells at full resolution, as a matrix to select cells from.
Reads the ZapBench recording starting from its cells: every cell at a reduced scale, or listed cells at full resolution, as a matrix for a Heatmap. Shift-drag rows on the expanded Heatmap and wire Selected Rows into ZapBench to Neurons to get the matching fish2 neurons.
Work with what came back: filter, join, aggregate, pivot or build a network.
neuron.attachAttributesGeometry, Table → Geometryruns as you edit
Join a table’s columns onto skeletons, meshes or points, matched on an id column. A carried column replaces a same-named one and keeps its position; nothing is suffixed.
Joins the columns of a table onto skeletons, meshes or points, matched by neuron id. Use it to colour or split a 3D scene by something computed elsewhere, e.g. a Cut Tree cluster or a Reduce Matrix statistic. With no columns picked, every column is attached.
net.buildEdges, Node attrs? → Networkruns as you edit
Turn an edge table into a network of nodes and links. The columns you pick are renamed: links carry `source`, `target`, `weight` and `edges`, and nodes carry `id`, `degreeIn`, `degreeOut`, `weightIn` and `weightOut`. These are the names downstream pickers see.
Turns an edge table, typically from Connectivity, into a network of nodes and links with in/out degree and weight per node. Optionally joins a table of node attributes such as cell type. Wire the result into the Network Viewer, Network Metrics or Network Centrality.
neuron.cleanMeshesMeshes → Mesheswaits for Run
Remove internal membrane, fill holes, decimate and smooth meshes.
Four optional repairs for EM meshes, applied in this order: remove the membrane folded inside the cell, fill the holes that leaves, decimate to a fraction of the faces, and smooth. Remove internal membrane before measuring surface area or volume, since a raw segmentation mesh has more surface inside the cell than around it. It is by far the slowest step.
neuron.cleanSkeletonsSkeletons → Skeletonswaits for Run
Heal, smooth and re-sample skeletons before measuring or comparing them.
Heal, smooth and re-sample traced skeletons, in that order: reconnect fragments, take out tracing jitter, then lay the nodes out at an even spacing. Re-sample before NBLAST or any measurement that averages per node. Distances are in micrometres; the number of neurons never changes.
cluster.clustersToNeuronsClusters, Neurons? → Neuronsruns as you edit
Put cluster numbers back onto the neurons they came from. `cluster`, `order` and `size` are carried along, and any column whose name the neuron table already uses is suffixed `_c`.
Maps the cluster numbers from Cut Tree back onto the neurons they came from, e.g. to colour by cluster in Neuroglancer. Wire the neuron table you clustered into Neurons and set Match on to the column NBLAST used for Label by.
core.combineColumnsTable → Tableruns as you edit
Merge several columns into one, taking the first non-empty value in the order picked. The result is named by `Into` (shown as Result, default `type`): naming one of the picked columns fills its gaps in place, and any other column already holding the name is suffixed `_2`.
Merges several columns into one, taking the first value that is not null or blank in the order you pick them, e.g. cell_type, then hemibrain_type. Naming the result after one of the picked columns fills its gaps in place. The default name is type, the column Coda reads cell types from.
biophys:combineTracesTraces 1, Traces 2 → Tracesruns as you edit
Put traces from several tables on one time axis, interpolating each onto it, so a recording and a simulation plot together.
Lines up tables of traces sampled at different times, such as a recording from Load Recording and the Traces from Simulate Model, by interpolating each onto one time grid. Shift an input to align its stimulus with another’s; a recording’s sweeps become a column each. Outside an input’s own time range its columns are empty rather than extrapolated.
compare.connectivityEdges 1, Labels 1, Edges 2, Labels 2 → Comparison, Countsruns as you edit
Put the same type-to-type connections side by side across two or more connectomes. Columns are `preLabel`, `postLabel`, then `weight_<name>` and `present_<name>` for each dataset, named by its `Name` param.
Puts type-to-type connections side by side across connectomes. Wire in each dataset’s edge list plus its labels from Match Cell Types; each row then reads e.g. “LC4 to DNp01 is 30 synapses here and 6 there”. A weight of 0 means not connected, an empty one means the type is missing from that dataset.
biophys:modelSkeleton, Synapses (exc.)?, Synapses (inh.)? → Modelruns as you edit
Builds one neuron’s skeleton into a compartment model — passive cable, voltage-gated channels by region, and its input synapses placed where they sit — for Simulate Model to run.
Turns one neuron into a compartment model: its skeleton cut into compartments, a passive membrane from a published preset, and a wired synapse cloud placed on the arbour, grouped by presynaptic partner. Wire Skeletons for one neuron and Synapses Between with this neuron as the target.
cortex:depthPoints, Dataset → Points, Tablewaits for Run
Adds each point’s `depth` below the pia (µm), its `layer` and its `lateral` position, and on a synapse cloud the cell types `type` and `partnerType` at either end.
Adds cortical depth below the pia (in µm), layer and lateral position to each point of a point cloud, using the dataset’s cortical frame. On a synapse cloud it also adds the cell types of each neuron and its partner. Usually fed by Synapses, with the table going into Laminar Profile or Group By.
cluster.cutTree → Clusters, Treeruns as you edit
Cut a merge tree into groups, by number of clusters or by distance. The Clusters table has the columns `label`, `cluster`, `order` and `size`.
Cuts a Linkage tree into groups: either a fixed number of clusters, at a distance threshold, or (for two connectomes clustered together) into groups that contain neurons from every dataset. Fast, so you can try different cuts while looking at the Dendrogram.
core.dedupeTable → Tableruns as you edit
Drop repeated rows, comparing on the chosen columns, or on whole rows if none are chosen.
Drops rows that repeat, comparing on the columns you pick (or on whole rows if you pick none). Keep decides whether the first or last row of each repeated set survives, or none of them. Typically used to get one row per neuron out of an annotation table.
neuron.distanceQuery, Target? → Matrixwaits for Run
Measure how far apart neurons are in space, or how much of one lies close to the other, as a matrix.
Measures how far apart neurons are in space, as a matrix in micrometres: closest approach, mean separation, distance between centroids, or how much cable lies within a given distance of the other neuron. Wire skeletons or meshes into Query for an all-by-all, or a second set into Target. The result can go straight into Linkage.
net.dotmotifNetwork → Matches, Induced unionwaits for Run
Search a network for a DotMotif pattern, locally in your browser.
Searches the wired network with DotMotif’s GrandIso executor, including node and link attributes. Required edges must connect all roles. Matches lists each role’s node per occurrence; Induced union keeps every link between matched nodes. Runs locally and can be cancelled.
core.editTableTable → Tableruns as you edit
Overwrite values in the rows a rule matches. Naming a column the table lacks creates it.
Overwrites values in a table using rules: which rows (a filter like type==LC4 status==Traced, or blank for all), which column, and what value. Use it to correct a few annotations or add a grouping of your own; naming a new column creates it.
core.embedMatrix?, Features?, Neighbours?, Only these?, Annotations? → Embeddingwaits for Run
Lay out a similarity matrix, a feature table or a nearest-neighbour table in 2D with UMAP.
Lays out neurons in 2D with UMAP so that similar neurons end up close together. Takes a similarity matrix, a feature table or a nearest-neighbour table; plot the result with a Scatter Plot. Distances between clusters are meaningless, and a different Seed gives a different layout.
net.filterNetwork, Seed? → Networkruns as you edit
Keep the part of a network around a selection of nodes: the selection itself, everything within a number of hops of it, or its whole connected component.
Selects nodes by a condition on any node column, by a wired table of ids, or both (the two are combined), and keeps them plus their neighbours within some hops or their whole component. Links with both ends kept stay. Build Network's degree and weight columns are recomputed for the remaining links. Useful for looking at one component of Match Cell Types' Network.
core.filterTableTable → Tableruns as you edit
Keep rows matching a condition on one column.
Keeps the rows that match one condition on one column, e.g. pre ≥ 100 or type starts with LC. The operators on offer depend on the column type. Chain several for AND; below a Link Table, the condition is applied to whatever rows are later read from the file.
biophys:fitModel, Recording → Model, Parameters, Traces, Iterationswaits for Run
Fits a Compartment Model’s passive membrane (Rm, Cm, Ra, E leak and an area factor) to a current-clamp recording; the fitted model, its parameters with standard errors, and the recorded and fitted traces.
Fits the passive membrane of a compartment model to a current-clamp recording from Load Recording by least squares: every sweep replays its own recorded command at the soma and the voltage is compared within a window. Says how well each parameter was determined. Plot Traces in a Line Chart to see the fit; wire Model into Simulate Model to run the fitted cell.
core.groupByTable → Tableruns as you edit
Collapse rows into groups and aggregate one or more value columns. The result carries the group columns, a row count named `n`, and one aggregate per value column named `<agg>_<column>`, so summing `weight` gives `sum_weight`, not `weight`. `agg: count` adds no aggregate column: its result is `n`, never `count` or `count_<column>`.
Collapses rows that share the same values in one or more columns and aggregates the rest, e.g. total synapses per cell type. Each aggregate is named <agg>_<column> (summing weight gives sum_weight), and a row count n is always added.
core.joinLeft, Right → Tableruns as you edit
Add columns from the right table to the left table, matching rows on a key column in each. A right-hand column whose name is already on the left is suffixed, `_r` by default.
Adds columns from the right table to the left table, matching rows on a key column in each. Type decides which rows are kept (left, inner, outer or right). Typically used to attach annotations to a neuron table; chain several Joins to combine more tables.
core.landmarkTransformLandmarks → Transformruns as you edit
Build a spatial transform from a table of matched landmark coordinates.
Turns a six-column table of landmarks (three coordinates before, three after) into a transform that Transform Neurons and Mirror Neurons can use instead of a built-in registration. Load the table with Upload Table or Table from URL, e.g. to use your own registration or a navis-flybrains one this build does not include.
cluster.linkageMatrix → Tree, Orderedwaits for Run
Cluster a score matrix into a merge tree.
Hierarchical (agglomerative) clustering of a square similarity or distance matrix, typically an all-by-all NBLAST. Wire the tree into a Dendrogram to look at it or into Cut Tree to get groups, and the reordered matrix into a Heatmap.
compare.matchTypesDataset 1, Dataset 2, Pass Through? → Labels 1, Labels 2, Report, Networkwaits for Run
Work out which cell types correspond between two or more connectomes, as a label table per dataset plus a report on each match.
Works out which cell types in one connectome correspond to which in another, using every type column the neurons carry. Wire each dataset in; the Labels outputs feed Compare Connectivity or Partner Vectors, and the Report shows how well each label matched.
neuron.mirrorNeurons, Warp? → Mirroredwaits for Run
Flip skeletons, meshes or points to the other side of the brain. The attribute table gains a `mirrored` column.
Flips skeletons, meshes or points onto the other side of the brain, so that a neuron can be compared with its partner in the other hemisphere in a 3D View or with NBLAST. The template space is read from the neurons, so usually there is nothing to configure.
neuron.nblastQuery, Target? → Scoreswaits for Run
Score how alike neurons are in shape, as a matrix.
Compare neurons by shape: NBLAST scores every pair on how well one neuron lines up with the other. Wire one set of Skeletons for an all-by-all, or a second set into Target to compare two groups. The output is a matrix of scores, typically clustered with Linkage.
neuron.nblastKnnQuery, Target? → Matcheswaits for Run
Find each neuron’s most similar neurons, as a table of matches with the columns `queryId`, `targetId`, `rank` and `score`.
Finds the top matches for each query neuron using NBLAST, scoring only a shortlist of likely candidates instead of all pairs, which makes it fast for large populations. The output is a table with one row per match, ready for Build Network or Embedding.
neuron.nblastMatchesMatrix → Matcheswaits for Run
Pull each neuron’s best matches out of a score matrix, as a table with the columns `query`, `target`, `rank` and `score`, or `query` and `matches` when counting. NBLAST k-NN names the same pair `queryId` and `targetId`.
Turns a score matrix into a table with one row per match: the neuron, its match, the rank and the score. Keep the top N matches per neuron, every match above a score, or every match within a fraction of the neuron’s own best score; or just count matches per neuron to help choose a cutoff. Any score matrix works, not just NBLAST’s.
net.centralityNetwork → Network, Node stats, Summarywaits for Run
Betweenness, closeness, PageRank, eigenvector centrality and communities for a network’s nodes. Each measure switched on adds its own column: `betweenness`, `closeness`, `pagerank`, `eigenvector`, `community`.
Adds betweenness, closeness, PageRank, eigenvector centrality and Louvain communities as columns to a network from Build Network. Slow on large networks, so it only runs on Run; use Sample to trade exactness for speed. Plot the columns with Network Metrics.
core.normalizeMatrix → Matrixruns as you edit
Rescale a matrix by its row or column totals, by its global maximum, or on a log scale.
Rescales a matrix: as fractions of each row or column total, as a fraction of the global maximum, or on a log scale. Usually sits between a Pivot of connectivity and a Heatmap or Linkage; row fractions stop numerous cell types from dominating the picture.
neuron.partnerVectorsConnections, Neurons?, Labels? → Vectorsruns as you edit
Turn a Connectivity edge list into one feature vector per query neuron, built from its upstream and downstream partners, for Similarity Matrix.
Turns a Connectivity edge list into one feature vector per neuron (its partners, split into upstream and downstream), ready to wire straight into Similarity Matrix. Wire Labels from Match Cell Types to compare neurons across datasets.
core.pivotTable → Matrix, Tableruns as you edit
Reshape a long table into a matrix of rows × columns, output both as a matrix and as a wide table. The wide table's columns are the distinct values found in the Columns field, so they are known only after a run.
Reshapes a long table into a matrix, aggregating one column for every pair of row and column values (e.g. preType × postType, summing weight). The Matrix output goes to a Heatmap, Normalize or Linkage; the Table output holds the same numbers as a wide table.
neuron.pointsInVolumesPoints, Volumes → Inside, Outsidewaits for Run
Split a point cloud by the meshes enclosing it, and add a `roi` column naming the volume each point is in. An existing column of that name is written over.
Tests every point against a set of meshes and returns the points inside a volume and those outside, with a column naming each point’s volume. Use it to assign synapses to brain regions, which neuPrint, CAVE and CATMAID do not provide. The volumes can be any meshes, e.g. other neurons. Where volumes overlap, the first one on the wire wins; the node reports how many points that affected.
core.qualifyIdsTable → Tableruns as you edit
Prefix neuron ids with the dataset they came from, or strip that prefix again. A prefixed id reads `dataset:id` and its column becomes text, so filters, joins and lookups downstream have to match that form.
Rewrites an id column to dataset:id so that two connectomes can share one table without their ids colliding, e.g. before stacking them for co-clustering. Strip the prefix again on the way back out. A prefixed id is no longer a valid neuron id, so nodes that fetch neurons refuse it.
core.reduceMatrixMatrix → Tableruns as you edit
Summarise each row or each column of a matrix as one table row. The result is `label`, the line’s `neuronId` where it is one, and one column per statistic you tick; `Prefix` renames those, so `zap` gives `zap_mean`.
Summarises each row (or each column) of a matrix with the statistics you tick, such as mean, max or sd, and returns them as a table keyed by label. Use it to get from a trace or similarity matrix to one number per neuron that you can sort, join or colour by.
core.relabelTable, Mapping → Tableruns as you edit
Rewrite a column by looking its values up in a two-column mapping table. The result goes into the column named by `Into` (shown as Result), or replaces the column in place when that is empty; any other column already holding that name is suffixed `_2`.
Replaces each value in one column with its match in a mapping table, e.g. body ids with cell types. Pick the column, then the mapping's key and value columns, and leave Result empty to rewrite in place. Values the mapping does not cover become empty unless Unmatched says otherwise.
core.renameTable → Tableruns as you edit
Rename one or more columns. If another column already has a target name, that column is suffixed `_2`.
Renames columns without changing their values. Mostly used to bring an outside table into Coda’s naming: neuron ids go in a column called neuronId, cell types in one called type. Renaming a column to neuronId turns the table into a Neurons table, and renaming neuronId away turns it back. A rename naming a missing column is skipped with a warning.
core.sampleTable → Tableruns as you edit
Keep a subset of the rows: the first or last N, every Nth, or a random draw.
Keeps a subset of a table's rows: the first or last N, every Nth row, or a random draw. Useful for cutting a large table down before plotting it or trying out an expensive step. Random draws are reproducible from their Seed.
core.selectTable → Tableruns as you edit
Keep only the chosen columns, in the chosen order. With none chosen, every column is kept.
Keeps only the columns you pick, in the order you pick them, e.g. to cut forty columns of neuPrint metadata down to the four you need before an export or a chart. With no columns picked, the table passes through unchanged.
neuron.selectNeuronsGeometry, Neurons → Geometryruns as you edit
Keep only the skeletons or meshes whose ids appear in a neuron table. Columns are left as they are: the geometry keeps the attributes it already had.
Keeps the skeletons or meshes whose ids appear in a table, e.g. a Cut Tree cluster, an NBLAST shortlist or a Connectivity result, without fetching anything again. Where you can, it is cheaper to filter the neuron table before the Skeletons or Meshes node. Ids with no matching geometry are counted and reported.
core.selectOneItems → Itemruns as you edit
Step through a table, skeletons or meshes and emit one element at a time.
Steps through a table, skeletons or meshes and passes on one element at a time, e.g. Explore Dataset → Select One → Skeletons → 3D View. Browse with the arrows and press Use this to send the element downstream, or turn on Live to send each one as you go.
cluster.selectedToNeuronsSelected, Neurons? → Neuronsruns as you edit
Turn a Dendrogram selection into neurons. The selection’s columns are carried along, and any whose name the neuron table already uses is suffixed `_c`.
Turns the leaf names selected in a Dendrogram back into neurons, ready for Neuroglancer, a 3D View or Skeletons. Wire the neuron table you clustered and set Match on to the column NBLAST used for Label by; if that was neuron id (the default), leave Neurons unwired.
core.similarityFeatures → Matrixwaits for Run
Compare every observation with every other over its features, as a similarity or distance matrix.
Compares every neuron (or other observation) with every other one over a table of features, e.g. connectivity from Partner Vectors, using cosine, Jaccard, Pearson or Euclidean. The square matrix it returns goes into Linkage for clustering or into a Heatmap.
neuron.simplifySkeletonsSkeletons → Skeletonswaits for Run
Prune short twigs and downsample skeletons, keeping the neuron’s shape.
Remove nodes from skeletons: prune twigs shorter than a cable length, then keep every Nth node or only the nodes where the neurite bends. Roots, branch points, leaves and the soma always survive, and no node moves, so an axon/dendrite split computed upstream comes through intact. Distances are in micrometres.
biophys:simulateModel, Record at?, Input spikes?, Current? → Traces, Input spikes, Output spikes, Partners, Arbourwaits for Run
Runs a Compartment Model with its partners firing and records the voltage at the soma and at wired points; tables of traces, input and output spikes and each partner’s effect, and the arbour coloured by peak voltage.
Runs a compartment model: partners fire on seeded spike trains or on times from a spike table, with optional current injection — a step, ramp, sine or pulse train — at any record site. Records the soma, any wired points and the traces added in Playback, and can run each partner alone to say how much it moves the soma. Plot Traces in a Line Chart; colour Arbour by node value in a 3D View.
neuron.skeletonPointsSkeletons → Pointsruns as you edit
Turn skeletons into a point cloud, one point per piece of cable, per skeleton node or wherever you place one by hand, with `neuronId`, `compartment`, `cable`, `radius`, `strahler` and `rootDistance` per point, and a `name` for each placed by hand.
Cuts each skeleton into pieces of at most Spacing µm and puts a point in the middle of each, for Cortical Depth, Laminar Profile or Points in Volumes. The `cable` column is the cable each point stands for and sums to the total cable length. `compartment` comes from the source: CAVE skeleton-service and SWC skeletons have one; neuPrint, CATMAID and level-2 skeletons do not. "placed by hand" takes points clicked onto each neuron in the expanded view instead — record sites for Simulate Model, say, or synapses of your own for a Compartment Model.
neuron.skeletonizeMeshes → Skeletonswaits for Run
Turn neuron meshes into skeletons, using the wavefront method.
Skeletonizes each mesh with skeletor's wavefront method, then shaves off the one-node twigs it leaves along the backbone, as navis does. Where the dataset knows where the soma is, the soma is labelled and each skeleton rooted there; `Clean up soma` also clears the tangle the method leaves inside it. A mesh in several disconnected pieces becomes a skeleton with several roots; `Min fragment size` drops small pieces first, and Clean Skeletons can heal the rest into one tree.
core.sortTable → Tableruns as you edit
Order rows by a column, optionally keeping only the top N.
Sorts rows by one column, descending by default, and can keep only the first N, e.g. the twenty strongest partners. Missing values always go last, whichever direction you sort in.
neuron.splitCompartmentsSkeletons, Synapses?, Volumes? → Skeletons, Synapses, Summaryruns as you edit
Label every skeleton node axon, dendrite or linker: from where its synapses are (navis’s synapse flow centrality or label propagation), from the ROIs it lies in, or from node tags.
Labels each neuron’s skeleton axon, dendrite or linker: from where its synapses are, by navis’s synapse flow centrality or by label propagation; from which wired ROIs it lies in; or from node tags a tracer placed (CATMAID). Wire in skeletons, and a Synapses cloud of the same neurons for the synapse methods. Open the card full size to inspect a split on a dendrogram and correct it by hand.
neuron.splitNeuronsNeurons → Matching, Restruns as you edit
Split skeletons or meshes in two by filter rows on their attributes: those that match, and the rest.
Splits a set of skeletons or meshes in two using filter rows on their attributes: neurons matching every row come out of Matching, all others out of Rest. Useful for taking a stacked scene apart again. With no filter rows, nothing matches.
neuron.stackInput 1, Input 2 → Neuronsruns as you edit
Combine several sets of skeletons, meshes or points into one collection, adding a `source` column (set by Source column) that names the input each neuron came from.
Joins several collections of skeletons, meshes or points end to end and stacks their attribute tables, as Stack Tables does for tables. Use it to show neurons from several datasets in one 3D View: transform each into a shared space, stack them, and colour by the source column. All inputs must be the same kind, in the same units and space.
core.stackInput 1, Input 2 → Tableruns as you edit
Append the rows of two or more tables, keeping every column any of them has.
Combines two or more tables by appending their rows, e.g. the results of the same query on two datasets. Every column of every input is kept, and an optional Source column records which input each row came from. To add columns instead, use Join.
neuron.synapseEdgesPoints → Edgesruns as you edit
Count a synapse point cloud into a connectivity edge list: `preId`, `postId` and a `weight` that is the number of synapses, the same column names Connectivity emits; `Split by` columns follow `weight`. The cloud needs a partner column, which Synapses Between has and a plain Synapses cloud on neuPrint or CATMAID does not.
Counts a synapse cloud into an edge list with one row per connected pair, weighted by the number of synapses. After Points in Volumes this gives connectivity within one region; Split by on a region column gives one row per pair per region. A plain Synapses cloud needs Orientation set to read its polarity column, or inputs and outputs are merged.
neuron.synblastQuery, Target? → Scoreswaits for Run
Score how similar neurons are by the positions of their synapses (syNBLAST), as a matrix.
Compares neurons by where their synapses are: for each synapse, the distance to the nearest synapse of the same polarity on the other neuron. Wire one Synapses cloud for an all-by-all matrix, or a second into Target to score one group against another. Two neurons with the same shape but different partners score high on NBLAST and low here.
neuron.xformNeurons, Transform? → Transformedwaits for Run
Move skeletons, meshes or points into JRC2018U, the shared template space.
Moves skeletons, meshes or points into the shared JRC2018U template space (or another dataset’s space), so neurons from different datasets can be shown together or compared with NBLAST. The source space is read from the neurons. If you also mirror, do that first.
core.unpivotTable → Tableruns as you edit
Fold wide columns into rows: one new column holds the original column name, another the cell value. The two are named by Name column and Value column, `name` and `value` by default.
Turns a wide table into a long one: each column you fold becomes rows, with its name in one new column and its value in another, and the columns you keep are repeated on every row. Use it on an already-pivoted CSV so Group By, Filter Table or a chart can treat those column names as a category.
cave.updateRootIdsTable, Dataset → Tablewaits for Run
Repoint stale CAVE root ids at a materialization or the live segmentation, using their supervoxel ids or a majority vote of their chunks.
Brings outdated CAVE root ids in a table up to date with a materialization, or with the live segmentation, using each row’s supervoxel id or, for a table without one, the root that most of the old neuron’s chunks ended up in. Usually sits between an annotation table and the CAVE Dataset it annotates; wire that Dataset into its Dataset input to say which datastack to ask.
Plot your results. Viewers pass their input through, so you can put them anywhere in a chain.
out.viewer3dSkeletons?, Meshes?, Points?, Volumes? → Selectedruns as you edit
Render skeletons, meshes, synapses and neuropil volumes in 3D, with data-driven colour.
Draws skeletons, meshes, synapse points and neuropil volumes together in one 3D scene. Wire in any of them, e.g. from the Skeletons, Meshes, Synapses and ROI Meshes nodes; each socket has its own colour setting, so you can colour neurons by cell type and synapses by polarity.
out.barChartTable → Tableruns as you edit
Bar chart of one numeric column, summed per category, with an optional series to stack by. Because it sums, a total per category needs no Group By in front; for a count of rows instead, put a Group By with `agg: count` in front and chart its `n`.
Bars of one numeric column per category, optionally stacked by a second column. Values are summed per category, so synapses per partner type can be charted straight from a Connectivity table. Changing its settings only redraws the chart; nothing re-runs.
out.distributionTable → Table, Selectedruns as you edit
Box plot, violin plot or swarm of a numeric column, split by an optional group.
Draws one numeric column as a box, violin or swarm per group, with quartiles, whiskers and outliers. The whisker rule, a log axis and the number of groups are settings; click a box to send that group's rows out of Selected.
out.datasetSummaryDataset →runs as you edit
Overview of a dataset: neuron counts, how they are classified, and how completely each region is traced.
An overview of a dataset: neuron counts, how they are classified, the most numerous cell types and how completely each region is reconstructed. Wire a dataset node into it; neuPrint datasets show the most, other backends only what they publish.
out.dendrogramTree, Annotations? → Tree, Selectedruns as you edit
Draw a merge tree from Linkage, select branches of it, and name its leaves from an annotation table.
Draws the tree from a Linkage node; click a branch to select its leaves and pass them on through Selected. Wire a neuron table into Annotations to label the leaves by cell type. Expand the card to zoom into large trees.
out.describeTable → Table, Summaryruns as you edit
Per-column summary of a table: how much is filled in, and the numeric spread. The summary's columns are `column`, `dtype`, `non_nulls`, `nulls`, `non_zero`, `unique`, `min`, `q1`, `median`, `q3`, `max` and `mean` (snake_case, unlike the rest of Coda).
Summarises a table with one row per column: dtype, present, missing and distinct counts, and for numeric columns the non-zero count, quartiles and mean. The table passes through and the summary comes out of a second port. Text, boolean and neuron id columns get the counts only.
out.flowChartNetwork → Network, Selectedruns as you edit
Draw a small network as a feed-forward circuit diagram: labelled boxes in layers, arrows weighted by connection strength.
Draws a small network as a circuit diagram: boxes in columns, arrows scaled by connection strength and labelled with the weight. Typically wired from Paths; for networks of more than a few dozen nodes use the Network Viewer instead. Feedback connections are dashed.
out.heatmapMatrix, Annotations? → Matrix, Selected Rows, Selected Columnsruns as you edit
Render a matrix as a heatmap, and name its rows and columns from an annotation table.
Draws a matrix (e.g. from Adjacency, Pivot or NBLAST) as a grid of coloured cells. Wire a neuron table into Annotations to label rows and columns by cell type, and use the Order tab to sort or cluster them. The relabelled, filtered and sorted matrix is also the output.
out.histogramTable → Table, Selectedruns as you edit
Histogram of one numeric column, optionally split into series by a second column.
Bins one numeric column into bars, e.g. to see whether a score or a cable length is skewed or bimodal. Bins follow the Freedman–Diaconis rule unless you set a count; a log axis, a cumulative curve and percent or density scaling are options. Click a bar to send its rows out of Selected.
cortex:laminarProfileTable, Dataset? → Table, Selectedruns as you edit
Histogram of a depth column drawn down the cortex with the layers behind it, split by a column, with a count per layer.
Bins a depth column and plots it down the cortex, with the dataset’s layers behind the bars and a count per layer. Feed it the Cortical Depth table of a synapse cloud and split by partnerType for a laminar input or output profile. Click bars or layer counts to send those rows on as Selected.
out.lineChartTable → Tableruns as you edit
Plot numeric columns against one numeric X as lines: one per Y column, per series value, or both. Voltage traces, time courses, profiles.
Draws one line per Y column against a numeric X, or one per value of a Series column for a long table — or both. With no Y picked it draws every numeric column, so a table of traces such as Simulate Model’s needs no setting; Y2 puts columns in other units, such as a current, dashed on a second axis. Long lines keep every spike.
net.metricsNetwork → Network, Node stats, Summaryruns as you edit
Graph statistics for a network: degree, clustering and components per node, and density for the whole graph.
Computes graph statistics for a network from Build Network: degree, clustering, k-core and components per node, plus density, reciprocity and more for the whole graph. The network passes through with the per-node metrics attached, so a viewer downstream can colour by them.
out.networkNetwork, Layout? → Network, Selectedruns as you edit
Node-link view of a network, with colour, size and shape driven by columns.
Interactive node-link diagram of a network, usually wired from Build Network. Colour, size and shape can follow columns, and nodes you click come out of Selected. The three filters (Min link weight, Top nodes, Hide isolated) also change the network passed downstream.
out.neuroglancerDataset, Neurons?, Extra layers? → Link, Selectedruns as you edit
View neurons in the dataset's own neuroglancer scene.
Shows neurons in the dataset’s own neuroglancer scene, embedded in the card. Wire in a dataset and, optionally, a neuron table such as the selection from Explore Dataset. The output is the scene URL, which you can open or share; all settings are in the inspector.
out.neuronDendrogramDataset, Neurons, Partners? → Neurons, Current, Pointswaits for Run
Draw one neuron flat — as a dendrogram, radially, navis’s subway layout or unrooted — with its synapses on it, against geodesic or electrotonic distance. Click a point to list the inputs and outputs distal to it; Run puts those synapses on the Points output.
Lays out one neuron’s arbour in the plane, with distance from the root on a real axis — geodesic, or electrotonic from the skeleton’s radii — and marks every synapse on it. Click a branch point to list the inputs and outputs beyond it and how far out they sit. Electrotonic distance needs a radius on every node, which CATMAID skeletons lack.
out.profileDataset, Neurons → Neurons, Currentruns as you edit
Inspect one neuron at a time: identity, partners by type, regions, transmitter and shape. Set Group by to a column to profile whole groups instead, e.g. one cell type per page, with each number a mean and spread across the members.
Summarises one neuron at a time: identity, partners by type, synapses per region, transmitter and shape. Set Group by to e.g. a type column to page through whole groups instead, with means and spreads. Usually fed from Explore Dataset; pinned neurons come out of Current.
out.topologyDataset, Neurons → Neurons, Current, Morphometricswaits for Run
Measure one neuron’s arbour and see where its partners synapse onto it. Morphometrics has one row per neuron (`cableLength`, `nodes`, `branchPoints`, `endPoints`, `maxStrahler` and more); splitting axon from dendrite adds `splitStatus`, `cableAxon`, `cableDendrite` and their synapse counts.
Morphometrics such as cable length, branch points and Strahler order for each neuron, beside a 3D view and a partner list that highlights where a chosen partner synapses. Split axon/dendrite uses navis’s synapse flow centrality and adds per-compartment columns; it is the only setting that needs a new download.
out.neuronbridgeDataset, Neurons → Neurons, Pinnedruns as you edit
Page through neurons and see the light-microscopy images NeuronBridge matched to each (split-GAL4 and MCFO lines, best image per line). Pin matches to send them downstream.
Shows NeuronBridge’s light-microscopy matches for one EM neuron at a time, one tile per split-GAL4 or MCFO line, to help you find a driver line that labels it. Typically wired to the Selected output of Explore Dataset; matches you pin with ☆ come out of Pinned.
out.pieTable → Table, Selectedruns as you edit
Pie or donut chart of shares of a whole: one slice per category, sized by a value column or, with none picked, by row count.
Shows the composition of a table as a pie or donut, one slice per category. Past eight slices the rest fold into one grey slice; click a slice to send its rows out of Selected. To compare sizes between categories, a Bar Chart is easier to read.
out.rankTable → Table, Selectedruns as you edit
Plot a numeric column against its rank on log axes, with the cumulative share of the total underneath: a Pareto or rank-abundance chart.
Plots a heavy-tailed column, such as influence scores, degree or centrality, as value against rank on log axes. A second panel shows the running share of the total, e.g. that the top twenty neurons carry 60%. The share is left out for columns with negative values.
out.roisDataset →runs as you edit
The dataset's neuropils drawn in 2D in a chosen anatomical plane, coloured by how completely each is traced.
Draws a dataset’s brain regions in 2D from the front, top or side, coloured by how completely each region is reconstructed. Wire a neuPrint dataset straight into it; Explode pushes overlapping regions apart.
out.sankeyTransfers → Table, Selectedruns as you edit
Draw layered flow as bands whose width is the quantity: a Sankey or alluvial diagram, from a table of layer, source, target and value columns.
Draws layered flow as bands whose width is the quantity, e.g. how drive passes through successive layers. Wired to the Transfers port of an Influence node it needs no configuration. The caption reports how far the flow is from conserved, which synapse counts usually are not.
out.scatterTable → Table, Selectedruns as you edit
Plot two numeric columns against each other, with colour, size and shape.
Plots two numeric columns against each other, with optional colour, size and shape channels, log axes and a linear trend. Typically wired from Embedding or any table; points you lasso come out of Selected.
out.tableTable → Table, Filteredruns as you edit
Show a table with sorting, paging and per-column filtering. The input passes through unchanged, and the rows that pass the filters come out of Filtered.
Shows any table as rows and columns that you can sort, page through, filter and export as CSV. The Table output passes the input on unchanged, so you can drop it anywhere in a chain; the Filtered output carries only the rows that pass the column filters.
vfb:infoTerms → Termsruns as you edit
What Virtual Fly Brain says about each term in a table, one page per term.
Shows Virtual Fly Brain’s page for each term in a table, one term at a time: its definition, the types it is a kind of, its relationships, the name each connectome gives it, example images, and the papers that describe it. Wire it after VFB Neurons to read its FBbt types, or pick any column of VFB ids. The card asks VFB for the term on screen only; running the node fetches nothing.
vfb:galleryImages → Images, Pinnedruns as you edit
Browse driver-line images as thumbnails, one per line, and pin the ones to load.
Shows the images from VFB Expression Images as thumbnails, one tile per driver line, and the one you open in a large view: its projection, or slices through its image stack. Pin an image with ☆ and it comes out of Pinned, ready for VFB Load Expression, so only the lines you chose are downloaded and drawn. Running the node fetches nothing.
Everything else: load your own tables, save files, run loops and leave notes on the canvas.
annotation:editorNeurons → Neuronsruns as you edit
Edit the annotations of a selection of neurons in FlyTable, SeaTable, Clio or a local CSV file, written back as you type.
Shows the annotations of the incoming neurons, read live from FlyTable, SeaTable, Clio or a CSV file on your computer, and lets you edit them on the card. Every edit is written back immediately. Wire in any set of neurons, e.g. a Find Neurons result or a Scatter Plot selection; the neurons are passed on unchanged.
flow.collectResult → Collectedruns as you edit
Combine the results of every pass of a For Each into one table or geometry collection.
Ends a For Each loop by combining the result of every pass into a single table or geometry collection. Nodes wired after it run once, on the combined result, e.g. a 3D View showing every skeleton the loop fetched.
out.copyIdsNeurons → Neuronsruns as you edit
Copy the incoming neuron ids to the clipboard, ready to paste elsewhere. The neurons pass through unchanged.
Copies the ids of the wired neurons to the clipboard when you click the button: one per line, or comma-separated and quoted for pasting into Python or R. The neurons pass through unchanged, so the node can sit anywhere in a chain.
out.downloadValue → Valuewaits for Run
Write the incoming value to a file (CSV, SWC, OBJ, or SVG/PNG of a chart), on every run or on demand.
Saves whatever is wired into it to a file: CSV for tables, SWC for skeletons, OBJ for meshes, SVG or PNG for the chart of the node feeding it. Passes its input on unchanged, so it can sit mid-chain; writes on every run unless you untick On run.
flow.forEachItems → Itemwaits for Run
Run everything downstream once per element, or once per group.
Runs everything wired after it once per element (a row, a skeleton or a mesh) or once per group. Follow it with Download to write one file per neuron, or with Collect to combine the results. Start it with the card’s Run loop button.
core.linkTable→ Table fileruns as you edit
Link a large Parquet, Feather or Delta table, on disk or at a URL, without loading it. Read Rows pulls out the rows you need.
Links a large Parquet, Feather or Delta table, on disk or at a URL, without loading it: only the footer is read, so its columns show up downstream straight away. Wire it into Read Rows to pull out the rows you need, e.g. the synapses of a few neurons.
biophys:loadRecording→ Tracesruns as you edit
Load an electrophysiology recording (ABF or NWB) as a table of its sweeps: time, sweep, a column per channel and the stimulus.
Brings in a patch-clamp recording, such as an ABF file from Clampex or an NWB file from DANDI, as one long table: time in ms, the sweep, a column per channel, and the command rebuilt from the protocol. Pick channels and sweeps, crop and downsample here; Combine Traces lines it up with a simulation. The file stays in this browser, so a colleague has to pick it again.
core.readRowsTable file, IDs? → Tablewaits for Run
Read rows from a Link Table file: the chosen columns, the rows matching a set of ids, up to a cap.
Reads rows from a Link Table file into an ordinary table you can filter, join and plot. Pick the columns to keep and, to look up specific neurons, a match column plus the ids, typed in or wired from a table. With a match column but no ids, nothing is read.
core.tableFromUrl→ Tablewaits for Run
Fetch a CSV or TSV from a URL and read it as a table. A chosen id column is renamed `neuronId` and a chosen type column `type`.
Downloads a CSV or TSV file from a web address and reads it as a table. The workflow stores only the address, so anyone opening it gets the same table. The host has to allow cross-origin reads; GitHub file links are handled for you.
note.textruns as you edit
A block of Markdown text on the canvas, e.g. to explain what a workflow is for.
A Markdown note on the canvas, e.g. to say what a workflow is for or why a threshold was chosen. It has no sockets and never runs or goes stale. Double-click to edit and press Escape to cancel the edit; in read mode, drag it anywhere.
core.uploadMesh→ Volumesruns as you edit
Loads your own region meshes from OBJ, STL or PLY files as Volumes the 3D View can draw.
Loads your own region meshes from OBJ, STL or PLY files, one mesh per file, as Volumes for the 3D View or Points in Volumes. Set Units to whatever the files are in. The meshes are stored in this browser, not in the workflow.
core.uploadTable→ Tableruns as you edit
Load a CSV or TSV of your own, such as annotations, cell types or an embedding. A chosen id column is renamed `neuronId` and a chosen type column `type`.
Brings in a CSV or TSV of your own, such as annotations, cell types or an embedding, to join onto other tables. The rows are stored in this browser, not in the workflow, so a colleague opening your workflow has to upload the same file again.