Nothing in this tool is scientifically necessary — a star with no spikes is a more honest star. But a Trapezium with four long diamond-sharp spikes, or M42 given the full JWST hexagonal treatment, is a lot of fun to make, and the physics underneath makes it look convincing instead of pasted on.
Every real telescope produces diffraction spikes because something partially blocks the incoming light before it reaches the sensor. A Newtonian's spider vanes make four spikes. A three-vane spider makes six spikes (each vane produces two). JWST's segmented hexagonal primary plus support struts makes the signature six-point burst with secondary rays. The pattern you see is the Fourier transform of the pupil shape — that's the physics, and it's what this tool simulates.
You give it a pupil (circular with vanes, or a JWST pupil image), it computes the PSF via FFT, and then at every detected star it places a scaled, color-weighted copy of that PSF on top of the existing stellar signal. Brighter stars get larger, more intense spikes; the star's own color biases the spike color; the three color channels each use a slightly different wavelength scaling so the spikes have the subtle red-outside / blue-inside chromatic edge you'd see in a real refractor.
The default. You design a pupil directly:
Toggle the Circular button to JWST and the circular-pupil controls disappear. The tool loads an actual image of the JWST pupil (18 hexagonal mirror segments, secondary support struts, central hole) and uses it directly. The result is the famous six-point burst with the characteristic small secondary rays between the main spikes.
Only Rotation remains active in this mode — it rotates the whole JWST pupil, which rotates all the spikes together.
SEP (Source Extractor as Python) finds stars to spike:
Press Generate Spikes to run detection and compositing. The result shows in the preview on the right (which has Zoom In, Zoom Out, and Fit to Preview controls — drag to pan). If you like it, press Apply to Active Document to commit it as a document edit (undoable from the history panel). If you don't, tweak settings and press Generate Spikes again.
The dialog is non-modal — you can keep working elsewhere while it's open — and Apply to Active Document leaves the dialog open so you can iterate further on top of the result if you want layered effects (e.g., first pass with the circular pupil for the main spikes, second pass with a wider blur for atmospheric diffusion).
If the active document has an active mask, it's respected automatically: white = apply spikes, black = protect the original. Useful for keeping spikes off galaxies and nebulosity, or confining them to one quadrant of the field. The blend happens after the full spike synthesis — the un-masked region gets the fully-spiked result, the masked region gets the untouched input.
The pupil is a 1024×1024 image built from an aperture (circle of radius R), an optional central obstruction (circle of radius Rε blocked out), and N vane strips passing through the center at evenly spaced angles.
where ε is the obstruction fraction and the coordinates (x, y) are measured from the pupil-image center. For each vane k, pixels within distance w (vane width in pixels) of the line through the origin at angle θ_k are set to zero:
where φ is the user-set rotation angle in radians. The final pupil is P with every V_k region zeroed out. Note the angles span [0, π) rather than [0, 2π) — this is the "N vanes → 2N spikes" fact at the implementation level: a single vane is already a line passing through the center in both directions, so you only need to place N of them to get 2N spikes.
If JWST mode is active, the pupil is loaded directly from a PNG file (shipped with the application): the 18 hexagonal primary-mirror segments, the secondary mirror obscuration, and the three secondary support struts, all in their correct geometric arrangement. The image is loaded as grayscale, normalized to [0, 1], and resized to 1024×1024. Rotation is applied via cv2.warpAffine with an affine rotation matrix. All other pupil controls (radius, obstruction, vane count/width) are hidden because the pupil geometry is fixed by the image.
Under the Fraunhofer (far-field) approximation, the amplitude point spread function at the image plane is the Fourier transform of the pupil function, and the intensity PSF is its squared magnitude. The implementation first applies a small Gaussian blur to the pupil (to tame aliasing from the discretization) and then takes the squared magnitude of the shifted FFT:
followed by a normalization pass:
and then a user-tunable Gaussian blur (the PSF Blur Sigma control) applied to the resulting intensity to soften pixel edges in the spike pattern. Both blur steps use cv2.GaussianBlur when OpenCV is available, falling back to scipy.ndimage.gaussian_filter otherwise.
Real diffraction spikes are chromatic — the PSF scales linearly with wavelength, so red light produces a slightly larger diffraction pattern than blue. The tool models this by computing three separate PSFs with wavelength scale factors:
Implementation-wise, each channel's PSF is computed, then the final intensity map is resampled by the channel's wavelength scale factor:
where s_c is the wavelength scale for channel c (1.15, 1.00, or 0.85). Longer-wavelength (red) PSFs are physically larger; shorter-wavelength (blue) PSFs are smaller and more concentrated. When the three channels are recombined, this gives the characteristic red-fringe-outside / blue-core-inside look that real refractor spikes have.
Detection uses SEP's background estimator and extractor against a luminance proxy computed from an un-stretched version of the image. The un-stretch applies the midtones transfer function (next section) with m = 0.95 to approximate the original linear data:
This is the Rec. 709 luminance weighting. SEP runs on L with the user-configured Detection Threshold (σ) above bkg.globalrms. Detected objects are filtered by flux and shape:
flux_min (user control)Each surviving object contributes a tuple (x, y, flux, a, b) to the star list used in the compositing stage.
Astronomical data lives in linear space, but display requires stretching. The midtones transfer function M(x, m) is applied twice in this tool — once with m = 0.95 to un-stretch the input for detection and compositing (so star fluxes make sense), and once with m = 0.05 at the end to re-stretch the result for display:
with the limiting cases M(0, m) = 0, M(1, m) = 1, and M(m, m) = 0.5 handled explicitly to avoid division by zero. The m = 0.95 pass flattens the display stretch so SEP sees star fluxes that reflect their actual relative brightness; the m = 0.05 pass re-applies a conventional display stretch to the spiked result.
For each detected star, the tool samples a small patch around the star's position (default radius 3 pixels, so a 7×7 window) and computes the per-channel mean color. The channel means are normalized by the maximum so the brightest channel always has ratio 1.0:
A red star gets (1.0, ~0.6, ~0.4); a blue star gets (~0.4, ~0.7, 1.0). These ratios multiply the corresponding channel PSFs, so the synthetic spikes inherit the star's color — red giants get red spikes, hot blue stars get blue spikes, white stars get neutral ones. For monochrome input, all ratios are 1.0 and the spikes come out neutral.
The intensity and size of each star's spike depend on its flux. The intensity (brightness) scales logarithmically with flux and is clamped to a reasonable range:
The size and brightness are then interpolated via a normalized flux coordinate α (linear in flux, clipped at flux_min and flux_max):
Note the inversion: B_scale grows with flux (brighter stars get a bigger intensity multiplier), while S_factor shrinks with flux (brighter stars get a smaller "shrink", which means the PSF tile is resampled larger — bigger spikes). The defaults are b in [10, 30] and s in [1, 5], meaning a maximum-flux star gets a 30× intensity boost and 5× smaller shrink factor than a minimum-flux one.
For each star, three per-channel PSF tiles are extracted from the center of the simulated PSF image at a tile size that scales with brightness (base 256 px, up to 768 px for very bright stars). Each tile is multiplied by brightness, color ratio, and the global spike boost:
The three channel tiles are then resampled by the per-star B_scale (zoom in by that factor) and 1/S_factor (shrink by the inverse of the shrink factor), using cv2.resize with bilinear interpolation when OpenCV is available (which is dramatically faster for large tiles) and ndi.zoom otherwise. The resampled R, G, B tiles are stacked into a three-channel patch and additively deposited onto a canvas at the star's position, with correct bounds handling for stars near image edges (partially off-canvas spikes are clipped to the valid region).
The whole per-star computation runs in a thread pool so a thousand stars don't become a thousand serial PSF resamples.
After all stars are placed, the canvas C holds the sum of all per-star spike patches. For a color image, the canvas is three-channel and simply added:
For a monochrome image, the canvas is collapsed to a single channel using the same Rec. 709 luminance weighting (0.2126 R + 0.7152 G + 0.0722 B) before adding. The addition happens in the un-stretched (linear-like) space, which is why the midtones un-stretch pass at the start matters — adding synthetic flux to an already-stretched image would otherwise saturate highlights disproportionately.
If the document has an active mask M (values in [0, 1]), the final output is a linear blend between the fully spiked image and the untouched original:
So white mask pixels (M = 1) show the full effect, black pixels (M = 0) show the original, and gray pixels give a weighted blend. This happens after the full compositing and re-stretch, so the blend is between two display-space images and reads correctly in the preview.