Skip to content

Design Choices

This page explains the decisions we made for proofreading in Catena, alternatives considered, trade-offs, and where we'd like to go next.

Problem / Goal

What outcome are we optimizing for?

Automatic segmentations and synapse detections are never perfect. Proofreading is the process that turns these model outputs into something we can actually trust for:

  • circuit reconstruction,
  • quantitative analysis,
  • and retraining / fine-tuning models.

The key challenges:

  • Proofreading is expensive and slow.
  • It needs to work at different scales:
  • small sub-cubes for generating high-quality ground-truth,
  • whole-brain volumes for circuit-level correctness,
  • object-level (synapses) for connectivity.
  • We want every proofreading action to be reusable:
  • as training data,
  • as validation data,
  • as an audit trail of what was fixed.

So this module's goal is to provide a small set of complementary workflows that:

  • integrate with tools people already use (Seg2Link, CAVE, CATMAID),
  • minimise friction for proofreaders,
  • and make it easy to feed corrections back into Catena.

Alternatives Considered

1. Local proofreading of sub-cubes

Option A - Manual voxel painting in generic tools

  • Pros: very flexible; any 3D viewer that supports painting can be used.
  • Cons: no dedicated UI for split/merge, no notion of segments or labels, higher cognitive and operational load for proofreaders.

Option B - Custom in-house napari plugins

  • Pros: full control; could be tailored exactly to our data.
  • Cons: extra maintenance burden, duplicated effort versus existing tools.

Decision: use Seg2Link for local proofreading.

Seg2Link already offers a 3D proofreading workflow on top of napari, with:

  • convenient inspection of 3D segmentations,
  • tools for correcting split and merge errors,
  • the ability to paint false negative regions directly.

At this stage, the only extra work on our side is converting Catena's Zarr outputs to TIFF stacks, which we handle with small conversion scripts.

2. Whole-brain proofreading of segmentations

Option A - Ad-hoc editing in standard viewers

  • Pros: trivial to set up; just open the segmentation in any 3D/2D viewer that allows editing.
  • Cons: no history; edits are hard to track, organise, or attribute; merging and splitting at whole-brain scale quickly becomes unmanageable.

Option B - Curation directly via skeleton-editing tools

  • Pros: closer to the neuron trajectories; intuitive for some workflows.
  • Cons: not inherently version-controlled at the segmentation level; harder to reason about global segment changes.

Decision: use CAVE (FlyWire) for whole-brain proofreading.

CAVE is essentially a version control system for segmentations:

  • it tracks all merge / split operations on neuron instances,
  • records who did what and when,
  • and offers an API and tooling ecosystem for import/export and analysis.

This makes it well suited for proofreading large, ingested volumes, where we:

  • proofread neuron trajectories either densely in regions of interest or sparsely-but-completely across the brain,
  • then export the corrected segmentations and use them as training/fine-tuning data for Catena models.

3. Automatic proofreading with skeletons

Option A - Ignore skeletons for proofreading

  • Pros: simpler; keep segmentation and skeleton workflows separate.
  • Cons: wastes high-quality tracing work that could help fix fragmentations.

Option B - Heuristic, geometry-based merging only

  • Pros: possible to merge segments based purely on spatial proximity.
  • Cons: blind to true neuron identity; likely to over-merge in crowded regions.

Decision: experiment with CATMAID skeleton-guided merging.

We already have CATMAID skeletons for some neurons. In this exploratory path, we:

  • use each skeleton as a "backbone" that should run through a single neuron,
  • detect where a single skeleton intersects multiple segments,
  • merge those segments automatically as belonging to the same neuron.

Caveats:

  • skeleton node placement is not always dense,
  • we often need to resample skeleton points and fit B-splines / smooth curves to better approximate true trajectories before using them for merging.

Because we currently do not have a huge number of fully complete skeletons, this remains an experimental workflow, with a prototype implementation in:

  • proofreading/auto_merge_seg_w_tracings.py

4. Synapse proofreading

Option A - Purely automatic synapse detectors (no proofreading)

  • Pros: easiest; no additional human effort.
  • Cons: false positives and false negatives directly distort the connectivity graph.

Option B - Spreadsheet / text-based curation

  • Pros: minimal tooling.
  • Cons: disconnected from the EM context; hard to reason about subtle ultrastructural features.

Decision: use CATMAID as the synapse proofreading environment.

Workflow:

  1. Synapse predictions from Synful or SimpSyn are exported and pushed into CATMAID as candidate synapse sites.
  2. Proofreaders inspect each candidate in the EM volume using CATMAID's native tools.
  3. Each candidate is tagged as correct synapse, incorrect synapse, or uncertain.

This gives us:

  • cleaned synapse lists for connectivity analysis,
  • curated validation sets,
  • and a consistent way to feed corrections back into model training and evaluation (see also the preprint on standardising crowdsourced synapse annotations).

Decision

We decided to support three complementary proofreading axes in Catena:

  1. Local sub-cubes (Seg2Link)
  2. Focus: high-quality corrections in small regions.

  3. Use case: generating ground-truth for retraining and detailed evaluation.

  4. Whole-brain segmentations (CAVE)

  5. Focus: neuron trajectories and large-scale merge/split errors.

  6. Use case: making full-brain segmentations usable for circuit reconstruction.

  7. Object-level proofreading

  8. Skeleton-guided automatic merging (CATMAID) for fragmented neuron segments.
  9. Synapse proofreading (CATMAID) for refining connectivity.

This combination lets us:

  • avoid reinventing complex UI tools,
  • keep proofreading close to where domain experts already work,
  • and turn corrections into reusable assets for Catena's models.

Trade-offs

  • Tooling diversity vs simplicity
  • Using Seg2Link, CAVE, and CATMAID means users may have to interact with multiple systems.

  • The upside is that we align with well-supported, field-standard tools instead of building fragile custom UIs.

  • Local vs global context

  • Seg2Link excels at small, detailed sub-cubes but is not designed for whole-brain version control.

  • CAVE provides global, graph-level context and history, but is more heavyweight to set up and integrate with.

  • Automation vs reliability

  • Skeleton-guided merging is attractive but currently constrained by skeleton availability and completeness.

  • Synapse proofreading relies on human judgement; it is slower but significantly more reliable than blind acceptance of model outputs.

  • Format conversions

  • Catena's internal processing often uses Zarr, while some tools (e.g. Seg2Link) expect TIFF.
  • We accept this conversion step as a practical compromise to benefit from those tools.

Implementation Notes

High-level structure:

  • Seg2Link workflow
  • Convert Zarr segmentations to TIFF sub-cubes.
  • Load EM + segmentation into Seg2Link (napari-based).
  • Correct split/merge errors and paint missing regions.

  • Export corrected labels for use as ground-truth.

  • CAVE workflow

  • Ingest whole-brain segmentations into CAVE. This is done in collaboration with Heinze lab in Lund University, Sweden.
  • Proofread merges/splits on neuron instances over time.
  • Export corrected segmentation and metadata.

  • Use exported labels for retraining / fine-tuning Catena models.

  • CATMAID skeleton merging

  • Load CATMAID skeletons and corresponding segmentation.
  • Optionally resample skeletons / fit B-splines.
  • Detect segments intersected by the same skeleton and merge them.

  • Experimental Script: proofreading/auto_merge_seg_w_tracings.py.

  • Synapse proofreading in CATMAID

  • Push Synful / SimpSyn synapse predictions into CATMAID.
  • Tag synapses as correct/incorrect/uncertain.
  • Export curated synapse tables for analysis and model improvement.

Operational Guidance

When to use which workflow?

  • Use Seg2Link when:
  • you want to create high-quality labels in small regions,
  • you are preparing data for retraining / fine-tuning a model,

  • or you need detailed local inspection of split/merge behaviour.

  • Use CAVE when:

  • you have a large or whole-brain segmentation,
  • you care about global neuron trajectories,

  • you want a clean history of merges and splits for many proofreaders.

  • Use CATMAID skeleton merging when:

  • you have reliable, (near-)complete skeletons,

  • and you suspect substantial fragmentation in the segmentation that follows those traced neurons.

  • Use CATMAID synapse proofreading when:

  • you already have Synful/SimpSyn predictions,
  • and you are building a cleaned, annotated synapse set to support connectivity analysis and model evaluation.

Practical tips

  • Always keep track of which corrections are intended as training data vs evaluation data; avoid mixing them.
  • For large-scale workflows (CAVE, CATMAID), rely on their built-in versioning/tagging instead of maintaining ad-hoc spreadsheets.
  • For Seg2Link, keep a simple manifest of which sub-cubes were proofread, by whom, and for which purpose.

Future Work / Open Questions

  • More automated prioritisation

  • Use model uncertainty or disagreement (between methods or runs) to prioritise which regions or objects to proofread first.

  • Deeper integration between tools

  • Tighter scripts for round-tripping data between Catena <-> CAVE <-> CATMAID <-> Seg2Link without manual bookkeeping.

  • Scaling skeleton-based proofreading

  • As more high-quality skeletons become available, expand skeleton-guided merging beyond a prototype into a more standard part of the pipeline.

  • Standardising synapse proofreading protocols

  • Building our standardising synapse annotation preprint and CATMAID workflows to define clearer guidelines for crowdsourced and expert synapse proofreading in EM connectomics.

The overall philosophy is to treat proofreading as an integral part of Catena, not an afterthought, and to keep evolving these workflows as more data, tools, and community practices emerge.