Streaks

On 5 February 2018, the first night of test operations, a new pipeline at the Zwicky Transient Facility (ZTF) found a short streak on a 30-second exposure and flagged it for follow-up. The object was a small near-Earth asteroid, designated 2018 CL, and it was the first of 45 confirmed discoveries the pipeline, ZStreak, made over 232 observable nights that year (Ye et al. 2019). Most were smaller than about 100 m. The same paper reports a sobering second number. Fifty-three other objects that ZStreak posted for confirmation were lost, because nobody observed them again in time. Every lost object had a discovery arc shorter than two hours. For the fastest movers, the detector is only the first link in a chain whose weakest link may be a telephone call to another telescope.

A body close to Earth crosses the sky fast enough to move several PSF widths during one exposure. Its photons then form a line, broadened by the point-spread function (PSF), rather than a point. The line carries information: position, orientation, angular rate, brightness, sometimes a rotational light curve. It also spreads the photons over more background pixels, so each pixel holds less signal. Finding that line efficiently is a planetary-discovery problem and, at the same time, the mirror image of a data-quality problem: the same feature might be a near-Earth asteroid to keep or an artificial satellite to mask.

The central distinction in this chapter is between two kinds of algorithm. One integrates weak evidence along a hypothesised line, so that a trail whose individual pixels are all below the noise can still be detected. The other recognises an elongated feature that is already visible, by thresholding, segmenting or classifying. Both are useful. They answer different questions, and their published performance numbers have different denominators.

From photographic plates to real-time pipelines

Streak discovery is older than electronic source extraction. Adam Waszczak and colleagues credit Eleanor Helin and Eugene Shoemaker’s photographic searches with the Palomar 18-inch Schmidt in the 1970s, published in 1979, as the first survey-scale application. David Rabinowitz introduced near-real-time CCD streak discovery with Spacewatch in 1991, and Spacewatch opened its Fast Moving Object imagery to public inspection in 2005 (Waszczak et al. 2017). These histories are as reported by Waszczak et al.; the original publications were not consulted for this chapter.

The mathematics is older still. Johann Radon defined the integral of a function along every line in 1917. Paul Hough’s particle-track work led to the Hough transform, and Richard Duda and Peter Hart’s 1972 normal-form parameterisation, $\rho=x\cos\theta+y\sin\theta$, is the one still used. The important practical difference is what goes in. Classical Hough voting follows edge detection or thresholding, so each pixel either votes or does not. A grayscale Radon sum keeps every signed pixel value. Weighted Hough voting sits between the two, and the name “Hough” alone does not tell you which you have (Nir, Zackay & Ofek 2018).

Measuring a trail well came before finding faint ones. In 2012 Peter Vereš, Robert Jedicke, Larry Denneau, Richard Wainscoat, Matthew Holman and Hsing-Wen Lin derived and tested an analytic model of a Gaussian PSF smeared along a line, on 30,000 synthetic trails and on Pan-STARRS1 data (Vereš et al. 2012). An elongated two-dimensional Gaussian, they showed, can place the centroid correctly while getting the trail length and flux wrong.

In 2018 Guy Nir, Barak Zackay and Eran Ofek supplied a statistical alternative to threshold-first extraction: the optimal matched filter for a line, computed with a fast Radon transform that shares partial sums between neighbouring lines (Nir, Zackay & Ofek 2018). Their telescope tests, on 20 July and 8 August 2017 at the Weizmann Institute’s Kraar Observatory with a 40 cm telescope, an Andor Zyla sCMOS camera and 1-second exposures, found GPS and low-Earth-orbit satellites, not new asteroids. In the same year Quanzhi Ye and collaborators adapted the PTF pipeline to ZTF’s 47-square-degree camera, and in 2019 Dmitry Duev and collaborators replaced most of the human screening with an ensemble of convolutional neural networks, DeepStreaks (Duev et al. 2019). Euclid’s small pixels and long exposures, which make even ordinary main-belt asteroids visibly trailed, prompted a separate line of work from 2020 (Pöntinen et al. 2020), and since 2025 neural detectors have been applied directly to whole difference images and to satellite trails in large archives.

The signal

Geometry of a trail

Let $D_i$ be the background-subtracted counts in pixel $i$. A trail is

where $F$ is the total recorded flux and $\vartheta=(x_0,y_0,\theta,L,\sigma,\dots)$ describes the trail’s centre, angle, length and width. Physically, the template is the instantaneous PSF $P_t$ integrated along the path over the exposure time $T$:

With constant flux $f$, a constant PSF and negligible acceleration $\mathbf a$, this is a line segment convolved with the PSF. Its length in pixels is $L=|\boldsymbol\mu|T/s$ for angular rate $|\boldsymbol\mu|$ and pixel scale $s$. Two caveats follow at once. The length gives the rate only if the body stayed on the detector for the whole exposure; a trail that enters or leaves the frame is censored. And a uniform, symmetric trail gives its orientation only modulo $180^\circ$: one image does not say which way the body was going.

For a circular Gaussian PSF of width $\sigma$, rotate to coordinates $u$ along the trail and $w$ across it. The normalised template is

with the standard error function $\mathrm{erf}\,z=(2/\sqrt\pi)\int_0^ze^{-t^2}dt$. The observed model adds a background and multiplies by $F$; undersampled images need the template integrated over each pixel (Vereš et al. 2012). One practical warning: the ZStreak paper prints a nonstandard prefactor in its explanatory definition of this function, so that definition should not be copied into code (Ye et al. 2019).

The matched filter

For independent Gaussian noise with known pixel variances $V_i$, the statistic is the same one used for point sources in Chapter 10:

For a fixed geometry $Z$ has unit variance under the null, and maximising the likelihood over non-negative flux gives $2\log\Lambda=[\max(0,A)]^2/B$. The Neyman–Pearson optimality of this test holds for a specified signal and noise. Searching over unknown geometry turns the alternative into a composite hypothesis and introduces a trials penalty. Nir et al.’s derivation assumes a straight line of constant brightness, a known constant PSF, background-dominated independent noise, and well-removed large-scale structure (Nir, Zackay & Ofek 2018, §2 and Appendix A). For correlated noise, from subtraction, interpolation or detector electronics, the sums become $A=\mathbf p^TC^{-1}\mathbf D$ and $B=\mathbf p^TC^{-1}\mathbf p$. Dividing a correlated image by its pixel RMS does not whiten it.

In practice one filters the image with the PSF first and then sums along lines, because filtering and line-summing are both correlations and commute. That gives the right numerator in uniform conditions. The denominator needs more care: adjacent filtered pixels are correlated, so the variance of a line sum is the norm of the whole PSF-broadened trail, not the sum of independent pixel variances. Nir et al. give a practical recipe: Radon-transform the variance map as well as the image, apply a geometric factor $g(\theta)=\max(|\cos\theta|,|\sin\theta|)$ for the different pixel density along diagonal lines, and divide. Even an image of uniform variance needs this, because different cells of the transform sum over very different numbers of pixels. Production code should check the recipe against direct template norms and noise realisations with its own masks and PSFs.

The trailing loss

How much does trailing cost? For a long trail with flux per unit length $\xi=F/L$, Gaussian transverse width $\sigma$ and uniform variance $V$ per pixel, the matched-filter S/N is the square root of the sum of the squared per-pixel S/N:

Compare a point source of the same flux, $\mathrm{SNR}_{\rm point}^2=F^2/(4\pi\sigma^2V)$. Their ratio, $2\sqrt\pi\sigma/L$, shows that for fixed total flux the trail’s S/N falls as $L^{-1/2}$. The matched filter recovers all the signal that is there; it cannot restore the concentration of photons that a point source enjoys (Nir, Zackay & Ofek 2018).

The exposure-time scaling is the more surprising consequence. For a body of fixed photon rate, $F\propto T$ and $L\propto T$, and in the background-dominated regime the sky variance per pixel $V\propto T$. The long-trail S/N therefore tends to a constant as the exposure lengthens: each extra second adds a new stretch of trail with the same S/N per unit length but lands on fresh pixels. In the read-noise-dominated regime, where $V$ per exposure is roughly fixed, it grows as $\sqrt T$. Either way, once a body trails, longer exposures stop helping.

For any length, correlating a normalised Gaussian with a uniform line gives an exact interpolation. With $a=L/(2\sigma)$,

which tends to 1 as $a\to0$ and to $\sqrt\pi/a$ for long trails. The loss in limiting magnitude is $-2.5\log_{10}q$. By contrast, a point-source PSF filter placed at the trail’s centre responds only to the part of the trail within about a PSF width, and keeps $q_{\rm pt}=(\sqrt\pi/a)\,\mathrm{erf}(a/2)$ of the point-source S/N. Both formulas are derivations for this chapter, from the same Gaussian model.

Trials and thresholds

A blind search tests many overlapping templates. For $M$ independent templates, the chance of any noise exceedance above $z$ is roughly $M\,\overline\Phi(z)$ when that is small, where $\overline\Phi$ is the Gaussian upper tail. Line templates overlap heavily, so counting every transform cell as an independent trial overstates the penalty, while ignoring the search understates it. Nir et al. sidestep the counting by measuring it: they fit an extreme-value (Gumbel) distribution to the maximum S/N found in each noise-only image. For simulated full-line searches the fitted location and scale are 4.7 and 0.216; for short-streak searches, 5.03 and 0.206. From 400 real images, after removing the five with detected streaks, they extrapolated that a threshold near 10.25 would give one false positive per million comparable images (Nir, Zackay & Ofek 2018, §7). The gap between that and the simulated 7.7 is a measure of how much heavier the tails of real data are. It is also an extrapolation from 400 images, not a test on a million, and it belongs to that camera.

How finely must the template bank sample geometry? For normalised, whitened templates $\widehat p$, a small parameter error loses S/N as

the same metric that governs template banks in gravitational-wave and pulsar searches (Chapter 38). Geometrically, an angular error $\delta\theta$ moves the trail’s ends sideways by about $L\,\delta\theta/2$, and that drift must stay small compared with the PSF width. A single angular step is therefore inefficient across a wide range of lengths: long trails need fine angles, short ones do not.

Methods

Thresholds, connected components and Hough voting

The simplest detector subtracts the background, thresholds pixels or a smoothed image, groups connected pixels into components, and keeps the elongated ones by their moments, width, flux or a correlation coefficient between pixel coordinates. A Hough variant has each retained pixel vote in $(\rho,\theta)$ space; a straight feature produces a peak, and the endpoints and width are recovered back in the image. Disconnected pieces vote for the same line, which helps with interrupted satellite trails and also connects unrelated stars.

For $K$ retained pixels and $A_\theta$ angle bins, voting costs $O(KA_\theta)$ on top of roughly linear preprocessing, with an accumulator of $O(A_\theta A_\rho)$ cells. Sparse voting is very cheap for bright trails. Its weakness for faint ones is structural: it discards sub-threshold evidence before integrating, and lowering the threshold to compensate fills the image with noise pixels that align by chance. Weighted grayscale voting avoids that loss and approaches a Radon sum. A Hough peak is also not a classification. Diffraction spikes, bad columns, trailed stars, cosmic rays, satellites and asteroids all make lines, while a curved, broken or flickering asteroid trail spreads its votes over several cells.

Template banks and trail fitting

A matched-filter bank evaluates $Z(x,y,\theta,L)$ for every position, angle and length. FFT convolution shares the work across positions for each fixed template, so $K$ angle–length templates on $P$ pixels cost about $O(KP\log P)$ plus normalisation and peak-finding. The bank gives full control: finite lengths, sub-pixel endpoints, empirical PSFs and exact template norms. Its cost is the repeated work across similar templates.

Once a candidate exists, a nonlinear fit on a small cutout is cheap. Fit flux, background, centre, length, angle and width, preferably solving analytically for the linear flux and background at each trial geometry. Vereš et al. found a two- to three-fold improvement in astrometry over the survey’s standard measurements for the longest trails of numbered asteroids, and suggested applying the fit selectively to detections with large second moments because of its cost (Vereš et al. 2012). Improved photometry from a correct trail fit is not extra photons, and it is not the same as a deeper blind search.

The Radon transform

The Radon transform integrates an image along every line. Nir et al. write the discrete version over lines that cross the whole image, parameterised by the starting column $x_0$ and the total horizontal displacement $\Delta x$ across the $N_y$ rows:

where $J$ is the PSF-filtered image. One transform covers slopes within $\pm45^\circ$ of the vertical; the transposed image covers the rest. There are $N_x$ starting positions and $2N_y-1$ displacements, and each sum touches $N_y$ pixels, so brute force costs $O(N_xN_y^2)$, or $O(N^3)$ for a square image.

The Fourier-slice theorem offers another route: the one-dimensional Fourier transform of a projection equals a radial slice of the image’s two-dimensional transform, so FFTs and polar-grid interpolation can replace repeated spatial sums. This is not the same discrete operator as the recursive transform below. Interpolation error, angular sampling, boundary extension and noise normalisation must be compared at matched sensitivity. And a full-image sum of either kind dilutes a short trail with all the empty pixels beyond its ends.

The fast Radon transform

The fast Radon transform (FRT) is dynamic programming. Lines with the same starting point and slightly different slopes pass through the same pixels for much of their length, so their partial sums can be shared. Work bottom-up. At the first level, add each pair of adjacent rows three ways: with no shift and with a shift of one pixel left or right. That covers every line within $\pm45^\circ$ across two rows. At the next level, combine adjacent two-row strips into four-row strips, now with seven possible displacements, and so on. At level $m$ the strips are $2^m$ rows tall, there are $N_y/2^m$ of them, and each holds about $2^{m+1}$ displacements; the product stays of order $N_xN_y$ at every level (Nir, Zackay & Ofek 2018, §3). The idea, like the FFT’s, is that two halves for which every line has been summed need only a little more work to give every line on the whole. The same recursive sharing of sub-paths underlies tree dedispersion in radio astronomy (Chapter 36) and William Press’s 2006 discrete Radon construction, which Nir et al. cite as a predecessor.

In the paper’s convention, with strip index $i$, signed displacement $j$ and intercept $k$ on the passive axis,

where $\mathrm{fix}$ rounds toward zero and $\mathrm{ceilfix}$ rounds away from zero; out-of-bounds values are zero. These recursively defined digital lines are not identical to lines drawn with some other interpolation rule, and comparisons between implementations should respect that.

The full-line transform needs about $2N_xN_y\log_2N_y$ additions per orientation, before padding the active axis to a power of two, preprocessing, normalisation and bookkeeping. Keeping two levels at a time needs $O(P)$ memory for $P=N_xN_y$ pixels; keeping all of them, $O(P\log N)$. The output has about $N_x(2N_y-1)$ cells per orientation. For typical astronomical images the authors estimate this to be two or three orders of magnitude fewer operations than brute force. They also suggest a neat diagnostic: run the transform on the PSF-filtered image to find astronomical streaks, and on the unfiltered image to find cosmic rays and artefacts, which are often a single pixel wide and do not share the PSF. Comparing the two responses helps tell them apart.

A complete pipeline looks like this:

calibrate and background-subtract; subtract or mask static sources
build valid-pixel and variance maps; correlate image with PSF
for orientation in (original, transposed):
    pad active axis to a power of two
    initialise single-row partial sums (image and variance)
    for level m = 1 .. log2(active size):
        combine adjacent strips with the FRT recurrence
        normalise with the transformed variance and g(theta)
        if strip height is in the searched length range:
            keep peaks above a permissive proposal threshold
deduplicate proposals in image coordinates
refit each with a finite, pixel-integrated trail model
apply a calibrated global threshold; classify artefacts
return endpoints, flux, covariance, flags

Short streaks and the dyadic penalty

Most asteroid trails do not cross the whole image. Nir et al. handle them by scanning the intermediate levels of the transform, whose cells are lines of height $2^m$ rows. The level that triggers gives the length to within a factor of two, and the cell gives the position and angle. Sensitivity is best when the streak happens to fall exactly within one dyadic strip, and worse when it straddles a strip boundary, because the best available cell then holds only part of the streak or dilutes it with empty rows.

The paper states that unfavourable placement can reduce the S/N by up to a factor of two. Its worked simulation is telling: a 72-pixel streak with a theoretical S/N of 17 gave 5.7 in the final full-image transform and about 13 at the best intermediate level. The fix is to trigger at a permissive threshold and refine each candidate with a direct scan over angle, position and length near the trigger. That refinement is not cosmetic. Without it, the short-streak search lost about a quarter of the S/N in the paper’s own example, and can lose up to half in the worst placement.

On real data the method recovered a very faint streak with about 1.3 S/N per resolution element (a segment one FWHM long) at total S/N of about 13 and 19 in consecutive frames. One PTF example ran in about 0.9 s on a 1024 × 1024 image, on hardware the paper does not specify (Nir, Zackay & Ofek 2018, §6). Python and MATLAB implementations are public (pyradon).

StreakDet and Euclid

StreakDet began as an ESA-funded pipeline for space-debris images, developed by Jenni Virtanen and collaborators and published in 2016 (Virtanen et al. 2016). It segments locally rather than summing coherently. Small- and large-window mean filters produce a contrast image, which is binarised; a modified erosion removes isolated pixels and reconstruction strengthens surviving structures; a multi-window density test rejects large stars, whose occupied area does not grow like a line’s. Connected components become candidates, characterised by width, orientation, aspect ratio, curvature and porosity. Pieces of one trail are linked and blended structures separated. A moving-Gaussian fit by Levenberg–Marquardt then refines each trail beyond its segmented footprint.

Mikael Pöntinen, Mikael Granvik and the Euclid team tested it on simulated VIS images: 565-second exposures with 0.1 arcsec pixels (Pöntinen et al. 2020). For objects brighter than magnitude 23 with trails longer than 15 pixels, about 10 arcsec per hour, single-streak completeness was 96.9%, and 99.1% were found in at least one of the four dithers. Detection fell steeply below about 13 pixels and approached zero below 9 pixels; it also approached zero near magnitude 25. Single-frame catalogues were full of false detections. Linking compatible trails across dithers, with example tolerances of 3° in orientation, 45% in length, 29% in flux and 44% in fitted PSF width, cut false positives by about three orders of magnitude; requiring two linked streaks left about 4% contamination. Requiring three gave an apparently pure test catalogue but lowered completeness over the whole test population from 55.66% to 44.36%. The runtime was about a minute per 4k × 4k CCD on one CPU core, plus about a minute per 144-image pointing for the linking.

ZStreak: discovery at ZTF

ZStreak runs on ZTF difference images. findStreaks thresholds pixels at 1.5σ, groups contiguous bright pixels and requires approximate linearity. Compared with PTF, the threshold on the Pearson correlation between pixel coordinates was relaxed from 0.65 to 0.55 and the nominal minimum length from 9 to 3 pixels; in practice the shortest reliable detections were about 5 pixels (Ye et al. 2019). Each candidate is then fitted with the finite Gaussian trail model; failed fits are retried from nearby starting points and discarded if they keep failing. The fitted parameters and uncertainties become 15 features for a random forest of 1,000 trees, trained on about 50,000 synthetic streaks moving at 5–50 degrees per day with magnitudes 15–20, and 50,000 bogus candidates.

A night produced of order $10^5$ raw candidates after the fit filter. At the adopted forest threshold of 0.05, the true-positive rate was 0.98 and the false-positive rate about 0.15 on validation data. Those rates are conditional on extraction. The upstream measurement is the one that matters for completeness: of 265 detections of known fast movers between $V=15$ and 20 and faster than 12 degrees per day, extraction plus fitting recovered about 72%, against 45% for PTF, and the detection limit moved from about $V=18.5$ to $V=19.8$. The authors attribute the gain mainly to cleaner backgrounds and tuning. Requiring two detections in a night, at 72% each, gives about 52% if the two are independent, which weather, field edges and recurring artefacts can violate.

The lost objects are the real lesson. Fifty-three posted candidates went unconfirmed, a loss rate of about 50%, compared with the authors’ quoted 11% average for other NEO surveys, and all had arcs under two hours. For the fastest, smallest bodies, latency and follow-up capacity are part of discovery efficiency (Chapter 14).

Neural classifiers and detectors

DeepStreaks is a classifier, not a detector: it screens ZStreak’s cutouts, resized to 144 × 144 pixels (Duev et al. 2019). Three families of networks each answer one question: is this a real elongated feature or bogus; is it short or long; and should it be kept as a plausible natural fast mover? Each family has a VGG6, a ResNet50 and a DenseNet121 model, and a candidate passes if at least one model in every family scores above 0.5. Training sets were built iteratively, starting from 1,000 human-confirmed streaks, 8,270 synthetic ones and 6,000 bogus examples of satellites, aircraft, masked stars, bad subtractions, cosmic rays and ghosts, then relabelling samples of a month of ZTF data and retraining. On a Tesla P100, training a single model for about 300 epochs on about 25,000 images took 1.5, 8 and 10 hours for the three architectures.

From 15 December 2018 to 15 January 2019 the ensemble reduced 7 million raw candidates to about 33,000; the earlier random forest had passed 1.7 million. Human scanners marked 270 of the 33,000 as real fast movers, and scanning time dropped from hours to typically under ten minutes a day. On 210 streaks of known NEOs already found upstream, the ensemble accepted 202, a rate the random forest matched. By 1 February 2019 the system had contributed 15 confirmed NEO discoveries, including 2019 BE5, reported (by private communication) to have a rotation period of 12 seconds. The paper describes one comparison as a fiftyfold improvement in false-negative rate, but the counts it cites measure candidate rejection; the counts and the conditional recall are the reliable numbers.

The 2023 Euclid pipeline detects directly on images (Pöntinen et al. 2023). A CNN with 2,043,975 parameters predicts, in 20 × 20-pixel windows, whether a streak is present and where its endpoints are; a bidirectional LSTM with 4,324 parameters merges overlapping streaklets; and a gradient-boosted ensemble of 644 trees links results across exposures. Among simulated objects appearing in at least two exposures, it reached 59.1% clean completeness at 95.4% purity; about 9% of objects appear in only one exposure and cannot survive linking. It reaches about 0.25–0.5 mag fainter than StreakDet but locates endpoints less precisely, with a median midpoint error of 0.6 pixel for bright streaks against StreakDet’s 0.1. The paper’s projected 50% increase in asteroid yield depends on an assumed magnitude distribution and is a forecast. Its timing breakdown, in which the GPU network is a minority of the runtime, is discussed in Chapter 23.

In 2025 Belén Yu Irureta-Goyena and colleagues applied a TernausNet segmentation network to whole ZTF difference images and refined detections with a finite-trail fit on the original pixels (Irureta-Goyena et al. 2025). Models trained on real, synthetic or mixed examples reached about $0.843\pm0.005$ completeness and $0.820\pm0.025$ precision on a test set of real asteroids. On a separate scanner sample the mixed model recovered about 80% of the scanners’ detections and 697 additional verified streaks, the great majority of them artificial satellites. The test asteroids were ones the operational pipeline had already recognised, so this measures recovery of a known population, not of the unseen one.

A 2026 benchmark warns against reading too much into any of these numbers in isolation. NEO-Bench assembles 8,376 images from five sources, including satellite imagery, meteor-network frames and Hubble asteroid trails. In leave-one-source-out tests, image-level F1 fell in 14 of 20 method–source combinations and localisation F1 in 13; even the best learned method generalised unevenly (He & Yao 2026). Domain shift is real. That does not show matched filtering fails, since the benchmark’s classical baselines include particular proposal and preprocessing choices.

Satellites: masking and robust Radon sums

Masking a satellite trail has a different objective from discovering an asteroid. A mask may err on the side of removing faint wings; a discovery search needs sensitivity at threshold and measured parameters. Masked area and lost astronomical sources matter as much as line recall.

David Stark, Norman Grogin, Jenna Ryon and Ray Lucas’s 2026 method for Hubble’s ACS/WFC replaces sums along Radon paths by medians (Stark et al. 2026). A single bright star can dominate a line sum; a median ignores it. For roughly Gaussian independent samples the median’s noise is $\sigma_{\rm median}\simeq1.25\,\sigma_{\rm image}/\sqrt{L_{\rm valid}}$, with masked pixels excluded and paths with fewer than 25 valid pixels rejected. Images are binned 2 × 2, and peaks in the median-Radon map are checked for width, cross-trail profile S/N and persistence along the image. At 0.5° angular sampling, a 2048 × 1024 transform took about 10 s on 24 cores at 3.10 GHz. In simulations it recovered long and corner-crossing trails with mean brightness down to about 0.13 and 0.37 times the pixel noise. In 358 Frontier Fields images it found 255 of 302 visually identified trails, with a false-detection fraction of 2.5% excluding easily recognised diffraction spikes, and about 10% in a larger archive run. The implementation is in STScI’s acstools (acstools findsat_mrt).

A median is not the Gaussian-optimal sum: it buys robustness in contaminated data with lower efficiency in clean data. It also does not fit the FRT recursion, because the median of two halves’ medians is not the median of their union. Replacing additions by medians in the fast transform does not give a fast exact median transform.

Archive-scale learned detectors have followed. Elisabeth Rachith and colleagues combined a Hough-transform branch with a line-detection CNN and a VGG6 false-positive classifier on VST/OmegaCAM data; applied to 1,246,048 CCD frames from 2023, it found 25,335 streaks (Rachith et al. 2026). On real data the detector’s precision alone was 0.783; the classifier raised it to 0.990 while keeping 97% of true positives. Streaks touched 16.9% of the year’s images but only 1.9% of individual CCDs. In two months that were reviewed by hand, 21% and 23% of confirmed streaks matched nothing in the public space-track catalogue, from which the authors estimate that at least 20% come from uncatalogued or unidentified objects. On an RTX 3090 Ti a full 16,000 × 16,000 mosaic took $13.36\pm0.78$ s of preprocessing, $32.91\pm0.45$ s of inference and $1.73\pm0.97$ s of stitching, about 48 s in all, with another 0.24 s of cutout generation and 0.03 s of inference per streak for classification. StreakMind uses oriented YOLO boxes and reports 94% precision and 97% recall on a held-out test of 110 trails and six background images (Carrillo Navarro et al. 2026). STARLINC segments trails using differences between adjacent frames, so it is not a single-image method; it reports 0.543 s per image and 2.25 GiB of peak GPU memory (Kim et al. 2026).

Avoiding the trail

The trailing loss is physical only once the exposure has been integrated. Splitting the same time into many short frames preserves the time information, and shift-and-add over trial velocities realigns the body before the sky noise is summed. This is synthetic tracking (Chapter 18). For $E$ frames, $P$ positions and $K_v$ trial velocities a direct search costs $O(EPK_v)$. It recovers the point-source concentration if the motion per frame is small, at the price of extra read noise, storage and a velocity trials factor. Chengxing Zhai and colleagues describe a system with 100 five-second frames of 61 megapixels each, 12.2 GB as 16-bit integers or 24.4 GB as float32, searched over a 100 × 100 velocity grid of about $\pm0.63$ arcsec/s per coordinate. They count about $6.1\times10^{13}$ operations and measure about 440 s on one 32 GB V100, with memory bandwidth and caching as the bottleneck (Zhai et al. 2024). Those operations are shifts and gathers, not multiply–adds, and should not be read as a tensor-core benchmark.

JWST offers a version of the same idea inside a single exposure. Its detectors are read non-destructively several times, and differences between cumulative reads (“groups”) form a short time series. Anthony Girmenia and Stanimir Metchev’s 2026 preprint fits these differences with generalised least squares, because adjacent differences share read noise, and validates the method on 13 detected moving objects and known-trajectory injections (Girmenia & Metchev 2026). The reported gain is about 1.1 mag for four groups, and an extrapolated 1.4 mag for six. A blind, covariance-aware, trail-matched search on group differences is left as future work, so these gains are not yet discovery gains.

Comparing the methods

Landmark results

Limitations and open problems

Sensitivity is not uniform in trail space. Short trails merge into the point-source population, where point-source detection and its morphology cuts take over. Long trails have low surface brightness, cross bright stars and leave the detector. Dyadic searches add a phase-dependent loss. A survey therefore needs completeness as a function of magnitude, length, angle, width, background and mask, not a single limiting magnitude. Euclid’s collapse below about 9 pixels and ZStreak’s dependence on rate are both examples.

A line is not an identity. A rapidly rotating satellite can glint for a fraction of a second and leave a short trail that looks like a fast NEA. Multiple exposures, rate consistency, catalogue association, context and follow-up separate them; geometry alone cannot.

The model is never quite right. Rotation modulates brightness, acceleration curves the path, atmospheric image motion makes satellite trails wobble, and the PSF varies across the field. A straight, constant-brightness template loses coherent S/N against all of these. Letting the brightness vary freely along the trail fits noise. Low-dimensional alternatives, such as a few brightness modes or a small curvature term, need their own false-alarm calibration. Nir et al. saw wobble and finite-segment losses in their own real data.

Masking and cleaning can delete the target. Bright-star masks remove pieces of trails, and aggressive cosmic-ray rejection can label a thin real trail as a detector artefact. The Hubble median-Radon code deliberately keeps cosmic-ray flags out of its preprocessing because those flags can cover parts of satellite trails. Euclid’s simulations found their cosmic-ray removal compatible with the simulated asteroid PSF, a result specific to that instrument and model.

Tests rarely cover the unseen population. Euclid’s test population was deliberately uniform in magnitude, speed and angle, a detection-envelope experiment, and its earlier simulation under-represented faint galaxies. The 2025 ZTF test set contained asteroids the operational pipeline had already found. Classifier ROC curves, segmentation scores and injection maps all stop at different pipeline boundaries, and few studies report end-to-end sensitivity at a fixed follow-up burden. A method that saves scanner time, or gets an object to follow-up an hour sooner, can produce more confirmed discoveries than a nominally deeper one.

Where the room is

The trailing loss in an integrated exposure is a hard limit: photons have been mixed with background along the whole path, and no filter unmixes them. Everything else in streak detection is algorithm and engineering. The proposals below are assessments, not demonstrated results; Chapter 42 places them among the book’s other open problems.

Start from an equal-sensitivity contract. Any comparison should fix the exposures, masks, allowed range of rates and lengths, injected population and final false-alarm budget. Inject pixel-integrated trails before preprocessing, including real backgrounds, randomised dyadic phases, brightness modulation and crossings of saturated stars. Report detection and fitted-position completeness separately, false candidates per exposure and per square degree, wall and device time, peak memory, and human and follow-up workload. A claimed tenfold speedup must reproduce the same recovery surface, not just the same threshold.

A GPU fast Radon transform is an engineering target. Each level is a large set of additions between shifted, contiguous rows: ideal for coalesced memory access along the passive axis, ping-pong buffers, batching many CCDs, and fusing normalisation and thresholding into the same pass so only candidates leave the device. The arithmetic intensity is very low. If each state reads two float32 values and writes one, a 4096 × 4096 image moves about $12\times2P\log_2N\approx4.8$ GB per orientation, or 9.7 GB for both, before padding and normalisation (an estimate, not measured traffic). The kernel is bandwidth-bound, and tensor cores are a poor match; a well-tiled addition kernel is the right baseline (Chapter 40). An order-of-magnitude gain over an interpreted CPU code is plausible but has not been demonstrated against an optimised GPU baseline that computes the same discrete lines.

Close the short-segment gap. The most consequential algorithmic gap is affordable, uniform sensitivity to short trails. Several staggered dyadic partitions reduce the boundary loss at a constant-factor cost; length-aware angular banks avoid oversampling short trails; prefix sums along a proposed line make endpoint scans cheap. Pruning partial sums early is tempting but dangerous: a faint real streak can have ordinary-looking partial sums, and a coarse mean does not bound the maximum over fine descendants. Any pruning needs a valid probabilistic bound or injection-calibrated completeness (Chapter 38).

Combine learned proposals with likelihood fits. Neural detectors are cheap at proposing candidates and good at rejecting complicated artefacts; likelihood fits restore physical flux, covariance and endpoint precision. Euclid’s network reached fainter objects but located them less precisely than StreakDet, which makes the hybrid case directly. A coherent filter bank run alongside the network can catch the low-surface-brightness trails that both the network and a binary extractor miss. The proposal stage must be tested for irreversible misses (Chapter 22).

Robust sums rather than an exact fast median. Clipped line sums, Huber losses, mixture-noise likelihoods and coarse star masks may recover much of the median’s resistance to stars while keeping the additive structure that the fast transform needs. This looks like a better opportunity than trying to build an exact median-of-medians recursion. Robustification changes the null distribution and can suppress real bright segments, so it needs calibration, not an optimality claim.

Profile the whole pipeline. In Euclid’s neural pipeline the CNN is a minority of the runtime, and Python association code dominates (Chapter 23). In OmegaCAM’s, inference dominates detection, but the per-streak cutout step dominates classification. Spatial indexing, angular binning, batched geometry and compiled association loops are first-order opportunities wherever they appear.

Change the data, not just the algorithm. Short frames, retained detector reads and JWST group differences restore the time information that trailing destroys, at the cost of read noise, storage and a larger search. Here the physical limit itself moves, which no post-hoc filter can do.

References

1. Virtanen, J., Poikonen, J., Säntti, T. et al. (2016). Streak detection and analysis pipeline for space-debris optical images. Advances in Space Research 57, 1607. doi:10.1016/j.asr.2015.09.024
2. Vereš, P., Jedicke, R., Denneau, L. et al. (2012). Improved Asteroid Astrometry and Photometry with Trail Fitting. PASP 124, 1197. arXiv:1209.6106
3. Waszczak, A., Prince, T. A., Laher, R. et al. (2017). Small Near-Earth Asteroids in the Palomar Transient Factory Survey: A Real-Time Streak-detection System. PASP 129, 034402. arXiv:1609.08018
4. Nir, G., Zackay, B., Ofek, E. O. (2018). Optimal and Efficient Streak Detection in Astronomical Images. AJ 156, 229. arXiv:1806.04204
5. Ye, Q., Masci, F. J., Lin, H. W. et al. (2019). Toward Efficient Detection of Small Near-Earth Asteroids Using the Zwicky Transient Facility (ZTF). PASP. arXiv:1904.09645
6. Duev, D. A., Mahabal, A., Ye, Q. et al. (2019). DeepStreaks: identifying fast-moving objects in the Zwicky Transient Facility data with deep learning. MNRAS 486, 4158. arXiv:1904.05920
7. Pöntinen, M., Granvik, M., Nucita, A. A. et al. (2020). Euclid: Identification of asteroid streaks in simulated images using StreakDet software. A&A 644, A35. arXiv:2011.05297
8. Pöntinen, M., Granvik, M., Nucita, A. A. et al. (2023). Euclid: Identification of asteroid streaks in simulated images using deep learning. A&A 679, A135. arXiv:2310.03845
9. Zhai, C., Shao, M., Saini, N. et al. (2024). Near-Earth Object Observations using Synthetic Tracking. Preprint. arXiv:2401.03255
10. Irureta-Goyena, B. Y., Helou, G., Kneib, J.-P. et al. (2025). Deep learning to improve the discovery of near-Earth asteroids in the Zwicky Transient Facility. PASP 137, 054503. arXiv:2504.11918
11. Stark, D. V., Grogin, N., Ryon, J., Lucas, R. (2026). Improved Identification of Satellite Trails in ACS/WFC Imaging Using a Modified Radon Transform. Preprint. arXiv:2602.17816
12. Carrillo Navarro, R., Duffard, R., García-Martín, P. et al. (2026). StreakMind: AI detection and analysis of satellite streaks in astronomical images with automated database integration. A&A 708, A211. arXiv:2605.03429
13. Rachith, E., Hellmich, S., Fiszbin, V. et al. (2026). Streak detection in the VST/OmegaCAM archive using deep learning. Preprint. arXiv:2606.30286
14. Kim, S., Lee, H., Kwon, D. et al. (2026). STARLINC: Satellite Trail Artifact Removal using Inter-Frame Correlation. Preprint. arXiv:2608.29145
15. He, J., Yao, J. (2026). NEO-BENCH: A New Multi-Source Benchmark for Generalizable Astronomical Streak Detection. Preprint. arXiv:2609.06774
16. Girmenia, A., Metchev, S. (2026). Increasing Sensitivity to Trailed Solar System Objects in Archival JWST NIRCam Imaging with Group Differencing. Preprint. arXiv:2609.27140
17. Nir, G. pyradon: Python implementation of the fast Radon transform streak finder. Software. github.com/guynir42/pyradon
18. Space Telescope Science Institute. MRT-based satellite trail detection (acstools findsat_mrt). Software documentation. acstools.readthedocs.io