Gaussian 2D 2C

Localize · version 3 · has a preview

Detect and fit both halves of a split frame as one emitter with a Gaussian PSF, sharing x and y: adds the photon ratio that tells the two colours apart. No PSF calibration; the registration can be measured from the movie itself.

What it does

This is the fitter for two colours on one camera in 2D. A dichroic mirror in the detection path splits each molecule's light between two halves of the camera chip, so every molecule appears twice in the same frame: once in the main (reference) half and once in the secondary half, a little shifted, turned and magnified. Both dyes appear in both halves, but in different proportions, and that proportion – the photon ratio – is what tells the dyes apart. This is ratiometric multicolour imaging (Bossi et al. 2008).

The plugin fits the two spots of a molecule together, as one emitter, the global fit of Li et al. 2022: one position for both halves, and a photon number for each. The position is then as precise as all the photons allow, and the photon split comes out of the same fit. At the end of the run it assigns the colours from that split (Assign colours) and, if asked, corrects the drift (RCC or COMET). The detection, the camera settings and the Gaussian PSF are those of Gaussian 2D, which explains them.

What it needs:

A split-frame movie, both halves in every frame, and the camera's conversion and offset, exactly as for the single-channel fitter.
The transformation between the halves: where the secondary half sees what the main half sees. There are three ways to get it. Tick calibrate from this movie and it is measured from the movie itself, which is the usual route, because in a ratiometric experiment every molecule is already imaged in both halves. Or choose a file: one written by an earlier run of this plugin or by Analysis/Register/Calibrate transform (*_2ct.h5), or a dual-colour bead calibration (Tools > Dual-colour calibration), whose transformation is used and whose PSF models are not. With neither, the run asks before it starts.

For 3D data with a bead calibration, use Spline 3D 2C; for one colour, Gaussian 2D.

How it works

1. The two halves, and the map between them. Which half is which, and where the seam is, comes with the transformation (its geometry: up-down or right-left, mirrored or not, which half is the main one). The transformation itself maps a position on the secondary half to the position on the main half where the same molecule appears. It is a projective map – a shift, a rotation, a magnification and a slight tilt of the image plane – or, when it was measured with the polynomial model, a third-order polynomial that also follows a field distortion. Positions are in pixels of the camera chip, so the same file serves a movie taken with another camera ROI on the same chip.

Left: one simulated frame. Each molecule appears in both halves; the lines join the two spots the fit treats as one emitter, each line starting at the main-half spot. Right: why a shift is not enough – where each point of the secondary half lands, less where the map's shift at the centre of the field would put it. What is left is the small turn and magnification between the halves, half a pixel at the edges of this 100-pixel field – as much as the precision many times over.

2. Candidates in both halves. Detection is that of Gaussian 2D – a difference-of-Gaussians filter and local maxima above the cutoff – with one change: the dynamic cutoff is set for each half on its own. The two halves are two detection channels that happen to share a chip; a cutoff set over both would be set by the brighter one, and the fainter partner of every pair in the dim half would not be found. (An absolute cutoff is the same number in both.)

3. Pairing. The peaks of the secondary half are mapped onto the main half with the transformation. A main peak and a mapped secondary peak within 4 pixels of each other, each the other's nearest, are one molecule: they become one candidate, at their mean position weighted by the square root of each peak's height. Peaks without a partner are kept: a molecule of the dye that puts little light into one half may be found only in the other, and it is still fitted. The candidate is rounded to a pixel in the main half, that pixel is mapped into the secondary half and rounded again, and a ROI (ROI size) is cut at each. A candidate whose two ROIs do not both fit inside the frame, each on its own half, is dropped.

4. One fit for both ROIs. Each ROI has its own Gaussian model, as in the single-channel fit, and the two are fitted at once by maximum likelihood: the Poisson likelihood of every pixel of both ROIs. What makes it one emitter is that some parameters are linked – one number for both halves – and the rest are free. By default:

x and y are linked (link x, y). One position for the molecule, seen in the secondary ROI through the transformation. This is what pins the two spots to one emitter, and what lets all the photons of both spots inform the position.
The photons are free (link photons off). Each half gets its own photon number, and their split is the colour.
The background is free (link background off): the two halves see different filters and need not have the same background.
The width is free (link width off). The halves see different wavelengths and are rarely in the same focus, so their spots have different widths; forcing one width on both would push the misfit into the photon numbers, which are what carries the colour.

Linking x and y gains precision because the two spots are two measurements of one position. With the photons split evenly between halves of equal PSF width, the position from both is times more precise than from one half alone – a little less here, because the secondary spot in the simulation is wider.

The gain from fitting both halves as one emitter. Spot pairs simulated at known positions, the photons split evenly, 10 background photons per pixel in each half, a 1.3 px PSF in the main half and 1.45 px in the secondary: the scatter of x about the truth (dots) and the precision the fit reports (lines), fitting the main half alone (orange) and both halves linked (blue).

5. The photon ratio. The fit gives each molecule photons_ch0 in the main half and photons_ch1 in the secondary half. Their total is photons, and the fraction in the secondary half is

between 0 (everything in the main half) and 1. Each dye has its own ratio, set by its emission spectrum and the dichroic, so a histogram of ratio over a two-dye sample has two peaks. How far apart they are, against how wide they are, decides how well the colours can be told apart; the width shrinks with the photons, as for a pure photon-counting spread.

The colour is in the photon split. The simulated molecules of the two dyes (true ratio 0.25 and 0.75, dashed) fitted from the frames above. Left: the histogram of ratio of each dye. Right: the ratio of every localization against its photons – the dim ones spread widest, and are the ones colour assignment is least sure of.

6. Finishing. When the last frame is fitted, two plugins run over the whole table, in this order (after the fit):

Drift correction, off by default: RCC or COMET, with their own settings under RCC drift and COMET drift. It is off because it takes minutes on a dataset whose size the form cannot know; COMET's question before a long run is not asked here, since choosing it is the agreement.
Colour assignment, on by default: Assign colours reads photons_ch0 and photons_ch1, finds the peaks of their ratio and writes a channel column – 1 and 2 for the two colours, 0 for what it will not assign. Its settings are under colour assignment.

They are the same plugins as in the Analysis tab, so a fit that finishes itself and one finished by hand afterwards give the same numbers; running Assign colours again later is how to change the rule. A step that fails is a line in the output and nothing more – the table is saved regardless. The localizations are written to the file as they are fitted; when a finishing step changed them, the file is written once more with the finished table, and both steps go into its history.

Calibrating from the movie. With calibrate from this movie ticked, a first pass runs before the fit. It fits frames of the movie with a plain Gaussian 2D fit over the whole frame, with the same camera and detection settings as the real fit (each half thresholded on its own about a provisional seam down the middle of the chip's longer side). Every molecule then shows up as two localizations in the same frame, and Analysis/Register/Calibrate transform's method finds the map from those pairs: the vector between every two localizations of a frame is collected, the offset between the halves is the one that turns up over and over, the pairs are matched through it and a projective map is fitted, then matched again, more tightly, through that map and fitted again. The frames are chosen carefully:

the first skip the first frames (500) are left out – at the start of a movie every fluorophore is on at once, and a fit of those frames is a mat of spurious positions;
100 frames are fitted first to measure how many localizations a frame gives in the dimmer half, and from that as many frames are taken as reach localizations wanted (at least 100, at most at most);
those frames are taken as spread over evenly spaced blocks across the whole movie, first at the start and last at the end, because a map fitted on the molecules of one minute describes the part of the field that was blinking in that minute.

The measured transformation is used for the fit and, with save it, written beside the output, as <acquisition>_locs_2ct.h5 by default, ready to be chosen as a file next time. The output box reports how many pairs it was registered on and the residual in x and y.

In detail

The model. For pixel of the ROI of half ( the main half, the secondary),

with the pixel-integrated Gaussian of Gaussian 2D. Each half has the five parameters , and the fitted vector holds one entry for each linked parameter and one per half for each free one – by default . A linked parameter reaches half through a factor and an offset,

and a free one as . The main half has , . For the secondary half, for x and y is the local scale of the transformation at the candidate (its derivative, by a one-pixel finite difference), and the offset is the sub-pixel remainder left when the partner ROI was rounded to a pixel, plus with half the ROI size, because the scale acts about the ROI's centre and not its corner. The link is diagonal: a rotation between the halves has no term of its own, and at the fraction of a degree of a splitter its effect within one ROI is far below the precision. The images are never resampled – warping one half onto the other would correlate the noise of neighbouring pixels and break the Poisson likelihood.

The fit. The deviance of Gaussian 2D, summed over the pixels of both ROIs, is minimised with the same Levenberg-Marquardt steps, with the gradient taken through the link:

Each half starts as the single-channel fitter would from its own ROI (centre of mass, border background, brightest pixel); a linked parameter starts from the main half's value. The limits (, , the width inside the ROI) apply per half, and a linked parameter is limited once, through the main half. A pair one of whose ROIs has no light at all is returned as not-a-number and dropped: the two halves are one measurement.

The precision. The Cramér-Rao bound comes from the Fisher information summed over both ROIs,

so a linked x collects the information of both spots. For two halves with photons each and the same width, without background, that is against for one half: the factor of the figure.

What is written. x_nm, y_nm are the linked position, in the main half's coordinates. With the photons free, photons is and photons_err the two errors added in quadrature; ratio is . With link photons on, one number is fitted and the halves see and for the photon ratio ; photons is their total, , and ratio is 0: there is no split left to measure. (Before version 2 it was the main half's alone.) logl_rel is the log-likelihood per pixel of the two ROIs together. EM gain and the camera's read noise are handled as in the single-channel fit (Gaussian 2D), the read noise in both ROIs. The first frames are checked against the transformation's geometry: a registration made on another camera ROI is refused, and a movie without a camera ROI in its metadata is taken to start at the chip's corner, with a warning.

Compared with the paper. The global fit is that of Li et al. 2022, whose software offers a Gaussian PSF beside its spline. Where the code departs from the publication:

The link. The paper links a shared parameter through a scale and a translation, the translation being the sub-pixel remainder left when the partner ROI is rounded to whole pixels. Here the scale for x and y is the transformation's local derivative, and it acts about the ROI's centre (the above), so a mirrored splitter, , needs no flipped image.
No bead calibration is needed. The paper builds its transformation from beads; here the movie alone can give it (calibrate from this movie), by voting on the vectors between localizations of the same frame.
Colour from the free photon split only. The paper also fits each molecule with the photon ratio fixed at each dye's value and keeps the most likely; that is not offered here.

Parameters

setting	default	what it does
source – Where the frames come from.
file `source.path`	–	Any file of the acquisition: a Micro-Manager TIFF series, an NDTiff directory, one image out of a folder written one file per frame, or a simulation (*.sim.yaml, File > Simulate).
first frame (more) `source.start`	0	Frames before this one are skipped.
last frame (more) `source.stop`	auto	Auto: to the end. at least 1
live `source.live`	off	The file is still being written: fit what is there and keep watching for new frames.
stop after (more) `source.live_timeout`	30 s idle	Live: give up after this long without a new frame. at least 1 s idle
frames per block (more) `source.chunk`	200	Frames read and detected at once; only memory and speed depend on it. at least 1
camera – ADU -> photons and pixel -> nm. Empty fields come from the file.
camera `camera.camera`	auto	Auto: identified from the file's metadata.
preset `camera.preset`	-	A camera YAML; fills the fields below.
conversion `camera.conversion`	auto	Photoelectrons per count; auto: from the file or the camera database.
offset `camera.offset`	auto	The count of a pixel that saw no light.
pixel size `camera.pixelsize_um`	auto	The pixel's size in the sample, after the magnification.
pixel size y (more) `camera.pixelsize_y_um`	auto	Auto: square pixels, the same as in x.
EM gain on `camera.em_on`	auto	An EMCCD with its electron multiplication on: the counts are divided by the gain, and the noise is doubled.
EM gain `camera.emgain`	auto	The EM gain the camera was set to.
read noise (more) `camera.read_noise_e`	auto	Rms per pixel; auto: 1 without EM gain (an sCMOS), 0 with it.
detection – Finding candidates in the filtered image.
filter `detection.filter`	difference of Gaussians	What the frame is smoothed with before maxima are looked for; the difference of Gaussians also removes a smooth background. Choices: difference of Gaussians; Gaussian
filter sigma `detection.sigma`	1.2 pix	The width of the smoothing: about the PSF's. at least 0.1 pix
cutoff `detection.cutoff_mode`	dynamic (x noise)	Dynamic: set per frame from the noise of the filtered image; absolute: a fixed value. Choices: dynamic (x noise); absolute (photons)
cutoff value `detection.cutoff`	1.7	Lower finds dimmer molecules, and more noise.
model – A free-width Gaussian per channel, and which parameters they share.
start sigma `model.sigma`	1.2 pix	The PSF width both halves' fits start from; each is fitted. at least 0.1 pix
link x, y `model.link_xy`	on	One position for both channels, through the registration; unlink only to check the transform. Unlinked, each half fits its own position. The table's position is the main half's, and `dx_nm_ch1`, `dy_nm_ch1` say how far the secondary half put the molecule from where the transformation expects it, in the main half's coordinates. Their median over the field should be close to 0 and their scatter about the precision; a trend across the field means the transformation does not hold there. Relink for the real fit: linked, both halves pin one position and the precision is better.
link photons `model.link_photons`	off	Off for two colours – the photon ratio is what tells the dyes apart. On, one photon number is fitted and the secondary half is expected to hold photon ratio times as many as the main: more precise, and no colour, and `photons` is the total over both halves. That suits two halves that see the same dye, not two dyes.
link background (more) `model.link_background`	off	One background for both halves; off: each half fits its own.
link width (more) `model.link_sigma`	off	Off: each half finds its own width, which it should – they see different wavelengths and rarely share a focus. Worth ticking only to test whether the two halves really differ in width.
photon ratio (more) `model.photon_ratio`	auto	Secondary / main, used when the photons are linked; auto: the beads' ratio if the transformation is a bead calibration, otherwise 1. Only used with link photons on; with the photons free it has no effect. Left on auto it is 1 for a transformation measured from localizations, and the beads' measured ratio when the transformation file is a dual-colour bead calibration.
transform – Where the second channel is.
transformation `transform.path`	–	From Register/Calibrate transform, or a dual-colour bead calibration. Ignored when calibrate from this movie is ticked.
calibrate from this movie `transform.calibrate`	off	Ignore the file: fit the first frames with a plain Gaussian and register them. The calibration pass fits at most at most frames with a plain Gaussian; then the real fit runs over the whole movie.
at most `transform.calibrate_frames`	5000 frames	The most frames the calibration pass fits, however few localizations they give. at least 50 frames
localizations wanted `transform.calibrate_locs`	10000	In the dimmer of the two channels, which is what limits the pairs; blocks are read until this is reached or the frame cap is. 10,000 in the dim half is usually plenty; a sparse movie runs out of frames first, and the output says so. at least 500
spread over `transform.calibrate_blocks`	10 blocks	The frames are taken as this many evenly spaced blocks across the whole movie, not as one run at the start. at least 1 blocks
registration – How hard to look, and what is already known.
layout `transform.registration.layout`	auto	How the chip is split: auto (detected from the pairs), right-left, up-down, or either mirrored. Auto tries plain, x-mirrored and y-mirrored and keeps the sharpest vote. Set it only when the automatic answer is wrong.
main_channel `transform.registration.main_channel`	auto	The reference half: auto, left, right, upper or lower.
model `transform.registration.model`	projective	Projective (8 coefficients), or polynomial (third order, 20) for a distorted field the pairs cover. polynomial is refused, with a message, when the pairs are too few for its twenty coefficients or cover less than half of the field; the projective map is then kept.
split_position `transform.registration.split_position`	auto	The seam between the halves, in chip pixels; auto: measured from the pairs.
vote_bin_px `transform.registration.vote_bin_px`	2	The bin, in pixels, of the histogram of pair vectors the channel offset is voted in.
vote_smooth_px `transform.registration.vote_smooth_px`	4	The width of the difference-of-Gaussians filter the vote is scored with, in pixels.
coarse_tolerance_px `transform.registration.coarse_tolerance_px`	20	First round: how far apart, in pixels, the partners may be after the voted offset. It has to cover what the voted offset alone cannot: a 3 degree rotation over 512 px is 27 px at the edge. Looser costs nothing measurable.
fine_tolerance_px `transform.registration.fine_tolerance_px`	1	Second round: how far apart the partners may be through the first round's map; 0 skips it. About seven times the residual of a healthy registration (0.13 px); tighter strips the edges of the field.
adapt_fine_tolerance `transform.registration.adapt_fine_tolerance`	on	Widen the second round's tolerance to the first round's misfit, when its pairs are clean.
min_pairs `transform.registration.min_pairs`	20	Fewer pairs than this and the registration refuses.
max_pairs `transform.registration.max_pairs`	20000	At most this many pairs, drawn at random, go into each fit.
reprojection_threshold_px `transform.registration.reprojection_threshold_px`	1	The robust (RANSAC) fit's inlier radius, at least; it widens with the tolerance.
transform_axis_limit_px `transform.registration.transform_axis_limit_px`	0.5	The largest \|dx\| or \|dy\| a pair may keep after the first fit, at least.
skip the first `transform.calibrate_skip`	500 frames	The opening frames of a movie are not single molecules: everything is on at once and often saturated, and fitting that gives a registration nothing to pair. Set it to 0 for a movie that does not start with everything on, such as a simulation, or one started after a bleaching phase.
save it (more) `transform.save_calibration`	on	Write the measured transformation beside the output, as *_2ct.h5.
fit – Everything about the fit that is not the camera or the PSF model.
ROI size `fit.roisize`	13 pix	The square cut around each candidate and fitted. Both ROIs of a pair have this size, and both must lie inside the frame, each on its own half. at least 5 pix
iterations (more) `fit.iterations`	50	The most steps a fit may take. at least 1
ROIs per fit (more) `fit.max_block_rois`	15000	How many are collected before they are fitted together; speed and memory only. at least 100
threads (more) `fit.n_threads`	0	0: one per core.
max fit distance (more) `fit.max_fit_distance`	auto	Reject fits that ran off; auto: keep all.
units `fit.output_unit`	nm	The unit of the positions in the table. Choices: nm; pixel; pixel+nm
output
save HDF5 `output.save`	on	Write the table to a file as it is fitted.
file `output.path`	–	Filled from the source: <acquisition>_locs.hdf5 next to the folder the images are in.
raw frames (more) `output.raw_frames`	50	Camera frames kept with the table, in photons, after their average; 0: none. 50 is enough to see what the camera saw at the start, the end and a few points between. Each kept frame costs its size in the file: for a 256 x 256 ROI about a quarter of a megabyte, for a full 2048 x 2048 sCMOS chip 16 MB, so fifty of those are 800 MB – set fewer there.
show image tags `output.show_tags`	PIZStage	Image tags drawn when the fit is done, names or parts of names; empty: none (Analysis/Process/Image Tags). `PIZStage` draws the piezo position, which shows at once whether the focus lock held. On a microscope whose piezo has another name, put that name (or part of it) here. Every tag that changed is kept in the file whatever this says; Analysis/Process/Image Tags draws any of them later.
after the fit – What is run over the finished table, before it is saved.
assign colours `finish.assign_colors`	on	Split the localizations by their photon ratio and write `channel` (Analysis/Dual-Color/AssignColors).
drift correction `finish.drift`	none	Estimate the drift from the finished table and subtract it from every localization. Off by default: it is minutes of work on a dataset it cannot see beforehand. Their pages, RCC and COMET, say which to choose; the settings under RCC drift and COMET drift are theirs. Choices: none; RCC; COMET
colour assignment
method `finish.colors.mode`	split at the minima	A cut in r, or a posterior per localization. Choices: split at the minima; probabilistic
colours `finish.colors.colors`	2	How many species the histogram of r holds. 1 to 6
exclusion dr `finish.colors.exclusion`	0.05	Minima: leave this much of r on either side of a boundary unassigned.
sigma `finish.colors.tolerance`	3	Probabilistic: a colour is given only within this many sigma of its expected split, the sigma being that localization's own photon statistics plus any extra spread. 0: assign to the nearest colour however far away.
keep the tails `finish.colors.keep_tails`	off	Probabilistic: apply the sigma test only between the outermost colours, so a localization more extreme than the first or the last mode is kept rather than refused.
allowed crosstalk `finish.colors.crosstalk`	0.05	Probabilistic: refuse what is too close to call as well – the largest expected fraction of wrongly assigned localizations. Narrow beside the sigma test, and what matters where two colours overlap. 1e-06 to 0.5
extra spread `finish.colors.spread`	0	Probabilistic: a species' own width in r, added in quadrature to the shot noise, for a dye whose splitting ratio varies across the field or between molecules. 0: shot noise alone (the summary prints what the modes suggest).
use fitted errors `finish.colors.use_errors`	on	Take the photon errors from the fit where the table has them; otherwise sqrt(photons).
use abundances (more) `finish.colors.use_prior`	on	Probabilistic: weight each species by how much of the sample sits under its mode.
minimum photons (more) `finish.colors.min_photons`	0	Localizations with fewer photons in total are ignored and left unassigned.
intensity LUT (more) `finish.colors.cmap`	viridis	The colour map of the intensity plot's 2D histogram. Choices: viridis; cividis; turbo; magma; inferno; Greys; Greys_r
histogram bins (more) `finish.colors.bins`	200	How many bins the histogram of r has over its whole range, -1 to 1. 10 to 2000
smoothing (more) `finish.colors.smoothing`	2 bins	The histogram is smoothed by this much before its maxima are looked for; it also sets how far apart two modes must be.
expected r (more) `finish.colors.expected`	auto	The species' ratios, comma separated ("-0.65, 0.96"), measured on single-label samples or computed from the spectra. auto: the histogram's own maxima.
channel 1 column (more) `finish.colors.channel1`	auto	Auto: photons_ch0, or the first pair of per-channel columns in the table.
channel 2 column (more) `finish.colors.channel2`	auto	The column r counts negative; name both columns or neither.
RCC drift – How finely to bin, render and search.
time windows `finish.rcc.n_timepoints`	20	How many windows the acquisition is cut into: more follow faster drift, fewer are less noisy. at least 2
pixel size `finish.rcc.pixelsize_nm`	15 nm	The pixel of the images that are correlated; about the localization precision. at least 1 nm
z bin (more) `finish.rcc.z_pixelsize_nm`	5 nm	The bin width of the z histograms. at least 0.1 nm
max drift `finish.rcc.max_drift_nm`	500 nm	The largest drift between any two windows that can be found. at least 1 nm
peak fit half-width (more) `finish.rcc.fit_window`	3 pix	The patch the correlation peak is fitted over, for its sub-pixel position. at least 1 pix
max image size (more) `finish.rcc.max_pixels`	2048 pix	A wider field of view is folded back onto itself, to keep the correlation fast. at least 64 pix
correct z `finish.rcc.use_z`	auto	Auto: if the table has z.
group blinks `finish.rcc.group`	on	Link the localizations of one blink into one before measuring.
group radius (more) `finish.rcc.group_dx_nm`	50 nm	How close localizations in consecutive frames must be to be one blink.
group gap (more) `finish.rcc.group_dt`	1 frames	How many dark frames a blink may skip.
tile (more) `finish.rcc.tile_nm`	200 nm	The axial pass correlates z histograms in tiles of the field of view this size. at least 1 nm
tile y (more) `finish.rcc.tile_y_nm`	auto	Auto: square tiles. at least 1 nm
max axial drift (more) `finish.rcc.axial_max_drift_nm`	200 nm	How far from zero the axial correlation peak is looked for. at least 1 nm
skip zero shift (more) `finish.rcc.exclude_zero_lag`	on	Leave the zero-shift sample out of the axial peak search.
COMET drift – COMET parameters. The defaults suit a typical SMLM movie.
window unit (more) `finish.comet.segmentation_mode`	frames	What window size counts; time-window fit only. Choices: frames; localizations; windows
window size `finish.comet.segmentation_var`	500	Frames or localizations per time window, or the number of windows; time-window fit only. at least 1
max drift `finish.comet.max_drift_nm`	300 nm	The largest drift expected; also the radius within which localizations are paired. at least 1 nm
target sigma `finish.comet.target_sigma_nm`	30 nm	The finest width of the overlap Gaussian, where refinement stops. at least 0.1 nm
initial sigma (more) `finish.comet.initial_sigma_nm`	auto	The width the refinement starts from; auto: a third of max drift.
smoothing (more) `finish.comet.boxcar_width`	1 windows	Running mean over this many windows between refinement steps; 1 is none; time-window fit only. at least 1 windows
interpolation (more) `finish.comet.interpolation`	cubic	The curve from the window estimates to every frame; time-window fit only. Choices: cubic; catmull-rom
max locs / window (more) `finish.comet.max_locs_per_segment`	auto	A random subset of at most this many per window; auto: all; time-window fit only. at least 1
ftol (more) `finish.comet.optimizer_ftol`	1e-07	Relative change of the cost at which the optimizer stops.
approximate kernel (more) `finish.comet.approximate_kernel`	on	Skip pairs more than 6 sigma apart; the spline fit always does.
ftol coarse (more) `finish.comet.optimizer_ftol_coarse`	auto	Ftol for the steps above the target sigma; auto: ftol; time-window fit only.
backend (more) `finish.comet.backend`	auto	Where the cost is computed; auto: the fastest available; time-window fit only. Choices: cuda; torch; cpu
quality control (more) `finish.comet.quality_control`	off	Discard time windows whose fit does not beat no correction; needs fit spline off.
min lift (more) `finish.comet.min_lift`	0	How much a window's fit must improve its overlap over no correction to be kept.
group blinks `finish.comet.group`	on	Link the localizations of one blink into one before estimating.
group radius (more) `finish.comet.group_dx_nm`	50 nm	How close localizations in consecutive frames must be to be linked.
group gap (more) `finish.comet.group_dt`	1 frames	How many dark frames a blink may skip.
two stage (more) `finish.comet.two_stage`	off	A grouped pass, then an ungrouped one within fine radius.
fine radius (more) `finish.comet.two_stage_radius_nm`	30 nm	The max drift of the second, ungrouped pass.
RCC first (more) `finish.comet.rcc_prepass`	off	Correlate rendered time windows to take out the bulk of the drift, then run COMET over a small max drift.
RCC windows (more) `finish.comet.rcc_prepass_windows`	10	The time windows RCC correlates. at least 2
RCC max drift (more) `finish.comet.rcc_prepass_max_drift_nm`	auto	Auto: RCC's own default.
fit spline `finish.comet.spline`	on	Fit the drift as a smooth curve in time rather than one value per time window.
knot spacing `finish.comet.spline_knot_frames`	2000 frames	Frames between the spline's coefficients. at least 10 frames
spline penalty (more) `finish.comet.spline_penalty`	0	Extra penalty on the curve's bending; 0 is none.
correct z `finish.comet.use_z`	auto	Auto: if the table has z.

Output

The table, one row per molecule and frame:

column meaning

x_nm, y_nm the position, in the main half's coordinates

x_err_nm, y_err_nm, xy_err_nm its precision (CRLB), from both halves

photons, photons_err the photons of both halves together

photons_ch0, photons_ch1 the photons in the main and the secondary half, and photons_err_ch0, photons_err_ch1

ratio the fraction of the photons in the secondary half

background_ch0, background_ch1 the background per pixel of each half (background is the main half's)

sigma_nm_ch0, sigma_nm_ch1 the fitted PSF width of each half (sigma_nm is the main half's)

channel the colour Assign colours gave it: 1, 2, or 0 for none

logl, logl_rel the log-likelihood, and per pixel of both ROIs

peak_x_nm, peak_y_nm, iterations the candidate in the main half, and the steps taken

column	meaning
`x_nm`, `y_nm`	the position, in the main half's coordinates
`x_err_nm`, `y_err_nm`, `xy_err_nm`	its precision (CRLB), from both halves
`photons`, `photons_err`	the photons of both halves together
`photons_ch0`, `photons_ch1`	the photons in the main and the secondary half, and `photons_err_ch0`, `photons_err_ch1`
`ratio`	the fraction of the photons in the secondary half
`background_ch0`, `background_ch1`	the background per pixel of each half (`background` is the main half's)
`sigma_nm_ch0`, `sigma_nm_ch1`	the fitted PSF width of each half (`sigma_nm` is the main half's)
`channel`	the colour Assign colours gave it: 1, 2, or 0 for none
`logl`, `logl_rel`	the log-likelihood, and per pixel of both ROIs
`peak_x_nm`, `peak_y_nm`, `iterations`	the candidate in the main half, and the steps taken

The finishing steps' figures – the ratio histogram of Assign colours, the drift curve – open with the fit's result.

What to check:

The preview. It draws the peaks found in both halves, and the secondary half's peaks mapped back onto the main half with the transformation (cyan crosses). A cross that sits on its partner's circle is a good registration; a cross beside it shows the error directly.
The ratio histogram should show one clear peak per dye. Peaks that merge mean too few photons or dyes too alike; a pile-up at 0 or 1 is molecules whose partner ROI held only background – a dye that sends almost nothing into one half, or a partner ROI placed where the molecule is not.
The two widths (sigma_nm_ch0, sigma_nm_ch1) should each be steady across the field; a width that grows towards one side is a half out of focus there.

The camera frames. The file also keeps a few of the frames the table was fitted from, in photons (counts minus offset, times the conversion): first the average of every frame fitted, then the first fitted frame, then the rest spaced evenly up to the last one, as many as raw frames asks for, each with its frame number – the same number as in frame. In the Render tab they are a source of an image layer, placed in the table's coordinates, so they lie under the localizations: whether a structure is really there, where the cell edge is, or whether the focus was lost can be checked without the original stack. The average is the one to start with; a localization of frame 17 should sit on a spot in frame 17.

Differences from SMAP

Based on SMAP's ratiometric workflow (fit_wavelet_dualcolorratiometric) and its global fit (fit_global_dualchannel, with the MLE_global_spline fitter in PSF free mode) (Ries 2020). The main changes:

Fitted, not measured, photons. SMAP's ratiometric workflow fits the whole frame single-channel and then goes back to the movie to measure the intensity of the partner spot at the transformed position (Get2CIntImagesWF, Intensity2Channel). Here both spots are fitted in one linked maximum likelihood fit, and the photon split comes out of it.
The transformation from the movie. SMAP's global fit needs it from an earlier registration (RegisterLocs2, cross-correlating rendered images). Here it can be measured in the same run, by voting on the vectors between localization pairs, weighted by their precision.
Detection per half. The dynamic cutoff is set for each half on its own; SMAP's workflows run one peak finder over the whole frame.
Raw frames by number, not by spacing. SMAP's CameraConverter keeps every diffrawframes-th frame after the average; here a number of frames is kept, spaced evenly over the fitted range, so that a long acquisition does not fill the file with them.

References

Bossi M, Fölling J, Belov VN, et al. Multicolor far-field fluorescence nanoscopy through isolated detection of distinct molecular species. Nano Lett 8, 2463 (2008). doi:10.1021/nl801471d – ratiometric multicolour localization with two detection channels.
Li Y, Shi W, Liu S, et al. Global fitting for high-accuracy multi-channel single-molecule localization. Nat Commun 13, 3133 (2022). doi:10.1038/s41467-022-30719-4 – the linked global fit this one follows, and its gain for ratiometric colour assignment.
Smith CS, Joseph N, Rieger B, Lidke KA. Fast, single-molecule localization that achieves theoretically minimum uncertainty. Nat Methods 7, 373 (2010). doi:10.1038/nmeth.1449 – the maximum likelihood Gaussian fit and its CRLB.
Ries J. SMAP: a modular super-resolution microscopy analysis platform for SMLM data. Nat Methods 17, 870 (2020). doi:10.1038/s41592-020-0938-1