Remove Stars

Separate stars from the background with your choice of engine — SyQon Starless, StarNet, or CosmicClarity Dark Star. The result replaces the view (mask-blended), and you can optionally keep a stars-only image. Linear data is temporarily stretched for the network and un-stretched afterward, so photometry survives.

1. Using the tool

Pick an engine from the chooser, configure it, and run. Whatever the engine, the outcome is the same shape: the starless image is blended back through any active mask and applied as a “Stars Removed” step, and — if you ask for it — a stars-only image opens as a new _stars document.

SyQon Starless

SyQon's starless models (Nadir, Axiom V2 / V2.1 / V2.2 / V3, Signal 1.0) are SyQon's own, obtained from SyQon — SASpro integrates them. Use the Get Starless Model Here… button to obtain a model, then Install Downloaded Model….

Control	What it does
Processing engine	SyQon Model (Integrated) runs the model inside SASpro; Starless Standalone CLI drives SyQon's separate executable instead (browse to it).
Model variant	Nadir / AxiomV2 / V2.1 / V2.2 / V3. Install, remove, or buy from the buttons. AxiomV2.2 can also use the optional Signal 1.0 model for star-core inpainting.
Tile size / Overlap	The image is processed in overlapping tiles; overlap must be smaller than the tile.
Apply temporary stretch (+ target median)	Stretch the image for the model and invert afterward (recommended for linear data) — see §2.1.
Also create stars-only document	Push the extracted stars as a new `_stars` view.
Pad edges / Pad pixels	Reflect-pad the frame before processing to improve edge-star removal, cropped back after.
Use AMP / RGB + Per-Channel	Mixed-precision for speed; the per-channel mode runs RGB and per-channel passes and averages them (slower, not available for AxiomV3).
Stars-only extraction	unscreen or subtract (see §2.2).
Live tile preview	Show tiles as they complete in a side window (slower; integrated engine only).
Target background (Advanced)	Auto-estimated from the image; reveal the control to override it.

StarNet

StarNet is a separate external program (StarNet++ / StarNet2). SASpro runs the executable you point it at (asked for once, then remembered) and auto-detects the classic vs 2.5+ command style.

StarNet asks whether the current image is linear. If yes, SASpro applies the temporary stretch (§2.1) before handing the frame to StarNet and inverts it on the way back; if no, the image is passed through as-is. A progress window streams StarNet's own output, and a stars-only image is produced alongside the starless result.

CosmicClarity Dark Star

Dark Star runs in-process (its mono AI model must be installed).

Control	What it does
Star Removal Mode	unscreen or additive — how the stars are separated from the background.
Processing Path	Mono AI per channel, Hybrid Luma + Color (best balance), or Color AI only.
Chunk Size / Overlap (%)	Tile size (power of two) and the overlap fraction between chunks.
Edge Padding	Reflected border added before processing to reduce edge artefacts, cropped back after.
Disable GPU / GPU Compatibility Mode	Fall back to CPU, or use a more conservative GPU path.
Show Extracted Stars	Also push the stars-only image.

Both config dialogs carry a grip (bottom-left) to mint a Remove-Stars shortcut with the current engine and settings, or drop on an image to run headlessly.

2. Technical details

The networks themselves belong to each engine; what SASpro contributes around them is an invertible stretch so linear data is handled correctly, and the maths that turns a starless frame into a clean stars-only layer.

2.1 Invertible stretch round-trip

Star-removal networks are trained on stretched (non-linear) data, so linear input is temporarily taken through a midtones transfer before the network and brought back afterward. Per channel, after subtracting the black point s, the forward transfer is the PixInsight MTF:

x'=\mathrm{clip}\!\left(\frac{x-s}{h-s},\,0,\,1\right)\,,\qquad y=\frac{(m-1)\,x'}{(2m-1)\,x'-m}

The midtone m is solved so the channel median M lands on the target (0.25) — the same analytic placement Statistical Stretch uses:

m=\frac{M\,(T-1)}{(2T-1)\,M-T}\qquad(T=0.25)

Crucially the transfer has an exact algebraic inverse, so the stretch fully round-trips and the returned starless image is mapped back to the original linear domain with photometry intact:

x'=\frac{\left((s+h)\,m-s\right)y-s\,m+s}{(2m-1)\,y-m+1}

Because the stretch is applied per channel with its own black point and inverted exactly, star colour and linear flux relationships are preserved — the network only ever sees a well-exposed image, but the committed result is linear.

2.2 Stars-only extraction

Given the original and the starless result, the stars-only layer is recovered one of two ways. Subtract is the straight difference:

\mathrm{stars}=\mathrm{clip}(\mathrm{orig}-\mathrm{starless},\,0,\,1)

Unscreen instead inverts the screen blend — the model that stars sit over the background rather than adding to it:

\mathrm{screen}(A,B)=1-(1-A)(1-B)\;\Rightarrow\;\mathrm{stars}=1-\frac{1-\mathrm{orig}}{1-\mathrm{starless}}

Unscreen is usually cleaner around bright cores (it doesn't leave dark halos where a star saturated), which is why it's the default for SyQon and an option for Dark Star.

2.3 Tiling, padding & masking

Large frames are processed in overlapping tiles (tile size + overlap); optional reflect-padding adds a border before processing and is cropped off afterward, so stars at the very edge are removed cleanly.
The starless result is blended back against the original through any active mask, so only masked regions change:
\mathrm{out}=\mathrm{starless}\cdot m+\mathrm{orig}\cdot(1-m)
A mono source is processed as RGB internally and collapsed back to a single channel on output; the stars-only document follows the same mono/colour shape as the source.

2.4 Notes

StarNet and the SyQon Standalone CLI are external programs; SyQon's models are obtained from SyQon. Dark Star runs in-process but needs its mono AI model installed. Each engine's own stretch/processing happens inside it; SASpro's MTF round-trip wraps the engines that expect stretched input.
Every engine records a replayable remove_stars preset (tool + its settings) for the workflow and grip/headless paths.