AI Tools

Removes light-pollution gradients, vignetting, and uneven sky glow from linear frames. The neural network predicts the background plane itself rather than fitting a polynomial, so it follows structure a fitted surface cannot. Two models are available: GraXpert's, and Polaris's own, trained from scratch and released under the AGPL.

• Two models: the GraXpert model (NonCommercial licence) and the Polaris model (AGPL, trained from scratch on real astrophotos). Both are downloaded on demand; pick whichever suits your licensing and hardware
• NPU-ready: the Polaris model also ships an int16 build, which is what lets it run on the Rockchip and Hexagon NPUs; the GraXpert model is fp32/fp16 only
• Predicts the background: the model outputs the gradient surface, which is then subtracted, so real nebulosity is not flattened away with the gradient
• Linear frames: run it before stretching, on calibrated masters, for the cleanest result
• Where: FILES tab, AI Tools toolbar, and the image Editor

Removes sensor noise (shot noise, read noise, thermal noise) while preserving fine astronomical detail. Three models are available: GraXpert v2 and v3, and Polaris's own, trained from scratch and released under the AGPL. Processing is tiled with cosine-feathered blending so no tile seam appears in the output.

• Three models: GraXpert v2 (lighter, for slower hardware) and v3 (higher capacity, better on faint detail and star spikes), both NonCommercial; plus the Polaris model (AGPL)
• The only one that fits every NPU: the Polaris model ships int16 and int8 builds. GraXpert v3 cannot run on the Qualcomm Hexagon at all, because it uses LayerNorm and that needs a V73 or newer NPU
• Tiled with feathered borders: images of any size are processed in overlapping patches, so no boundary artefact is visible
• Colour and mono: both RGB and single-channel FITS are supported; the pipeline handles the channel layout automatically
• Linear and stretched: works at both stages; best results on linear calibrated masters before stretching
• Where: FILES tab, AI Tools toolbar, and the image Editor

Sharpens point sources (stars) blurred by atmosphere, tracking error, or optical diffraction using a GraXpert neural network trained specifically on star fields. Produces tight, round stars without the ringing artefacts common in classical approaches.

• Star-focused: the model is trained to sharpen compact point sources; it understands that stars should be round and not produce halos
• Complements the Objects model: run Stars first, then Objects to sharpen both point sources and extended structure
• Tiled 256x256: feathered overlap blending; safe on full-resolution masters
• Before/after slider: inline comparison slider in the UI lets you judge the effect before saving
• Where: FILES tab and AI Tools toolbar, under AI Sharpen

Sharpens extended objects such as galaxies, nebulae, and clusters. The GraXpert Objects model is optimized for spatially extended structure rather than point sources, recovering fine detail in galaxy arms, dust lanes, and emission regions.

• Extended structure: trained on galaxy and nebula images to sharpen fine structural detail without over-sharpening smooth emission regions
• Pair with Stars: for full-image processing, run the Objects model after the Stars model; each complements the other
• Tiled 256x256: feathered overlap blending; no tile seams in the output
• Strength control: adjustable strength slider (0.1 to 1.0) lets you dial in the effect
• Where: FILES tab and AI Tools toolbar, under AI Sharpen

Polaris's own deconvolution network, trained from scratch on synthetic (sharp, blurred) pairs: every real astro image is already blurred by seeing, so there is no clean ground truth to learn from. Convolving sharp targets with a known PSF gives perfect pairs in unlimited quantity.

• Quantization-first architecture: designed so the int8 and int16 exports lose nothing. BatchNorm instead of LayerNorm, nearest-upsample plus conv instead of ConvTranspose, and a single input tensor
• Why those choices: they come from the NPU work. The Hexagon V68 rejects LayerNorm outright (it needs V73 or newer), ConvTranspose produces checkerboard artefacts that quantize badly, and GraXpert's multi-input design is what kept its deconvolution CPU-only
• Runs everywhere: one model lowers cleanly to Hexagon (int8/int16), Rockchip RKNN (fp16), the Adreno GPU, plain CPU, and the browser through ORT Web
• Versions: v1.1 ships fp32, fp16, int16 and int8; v1.2 adds a w8a16 build tuned for the Hexagon HTP
• Where: FILES tab, AI Tools toolbar, and the image Editor

Richardson-Lucy deconvolution driven by a PSF measured directly from the stars in the frame. The algorithm reverses the blurring introduced by atmosphere, tracking, and optics using the actual optical response of the imaging system rather than a generic neural network.

• Measured PSF: Moffat profile fit to real stars in the frame extracts FWHM, eccentricity, and orientation; the PSF is specific to that capture session
• White 1994 damping: corrections are gated by a per-pixel noise model; low-SNR regions are left untouched, preventing noise amplification
• Photon-transfer noise model: sigma is estimated from the frame itself using a shot + read noise model (sigma = sqrt(A*S + B)); no calibration input needed
• Star protection: a feathered mask around detected stars composites original star cores back after deconvolution, preventing ringing at bright sources
• FWHM and star stats: FWHM in pixels, eccentricity, and number of stars used are reported after each run
• Where: FILES tab under AI Sharpen, Classical RL option

Extends Classical RL to handle field curvature, coma, and tilt: the PSF is measured independently in a configurable grid of tiles across the frame. Each tile gets its own PSF, and the results are blended with cosine feathering. Ideal for wide-field imagers where star shapes change from center to corner.

• Per-tile PSF: Moffat profiles fitted in each grid cell independently; a corner affected by coma uses a different kernel than the center
• Configurable grid: 2x2 to 8x8 tiles; more tiles give finer spatial correction at the cost of longer measurement time
• Feathered blending: cosine blend between adjacent PSF regions; the transition is invisible in the final image
• Fallback: tiles with too few stars fall back to the nearest measured PSF, so the whole frame is always processed
• Where: FILES tab under AI Sharpen, Field RL option

A new mode where the server measures the PSF and noise model (typically 5 to 15 seconds), returns a compact JSON payload, and the browser runs the heavy Richardson-Lucy iteration loop entirely in JavaScript. The SBC server CPU stays free for guiding, sequencing, and capture during the job.

• Server does the science: PSF extraction, noise model fit, and star detection all run server-side; these are fast and CPU-light
• Browser does the work: a pure-JavaScript FFT engine (radix-2 Cooley-Tukey) runs 512x512 tiled overlap-save RL iterations in the browser
• Real-time progress: a progress bar updates after each iteration; you can see the image sharpen live in the before/after slider
• Same algorithm: identical White 1994 damped RL, star protection, and noise gating as the server-side version
• Enable it: in the AI Sharpen modal, check the 'Run in browser' checkbox (global RL mode only; field mode stays server-side)

Removes stars while preserving nebulosity, for narrowband and starless processing workflows. Polaris offers four different star-removal networks rather than one, and three of them are MIT-licensed, so they can be used commercially.

• nox colour and nox gray (MIT): StarNet-like networks in separate colour and monochrome builds; pick the one matching your data. 208 MB each, or 104 MB in FP16
• starrem2k13 (MIT): a lighter U-Net at 119 MB (59 MB FP16), the fastest of the four and a good first choice on an SBC
• StarNet++ (NonCommercial): the original network, included for compatibility with existing workflows. Its licence forbids commercial use, which is why the MIT alternatives exist
• arm64 throughout: all four run as ONNX on Raspberry Pi, Orange Pi and Radxa boards. StarNet v2 is excluded on purpose: it is an x86-only binary
• Blend-back control: after removal the original stars can be blended back at any opacity, for a final image with softened rather than absent stars
• Where: FILES tab and AI Tools toolbar, Remove Stars option

Polaris's own neural network, trained from scratch on real astrophotos, removes the diffraction halo rings that appear around bright stars in fast refractors and Newtonians. Unlike classical approaches, the model understands the spatial context of each star and avoids removing genuine nebulosity near bright sources.

• Polaris-native model: trained on our own dataset of real astrophotos with synthetic halo augmentation; not a GraXpert repackage
• Context-aware: RGB 3-channel input gives the model enough context to distinguish halos from nearby nebulosity and emission regions
• Evaluated at 50+ dB PSNR: fp16 variant is essentially lossless vs fp32; int16 is within 0.03 dB
• Four precisions: fp32 (reference), fp16 (recommended), int16 (NPU/PTQ), int8 with QAT for maximum compression
• Where: AI Tools toolbar and the Editor's AI section, Halo Removal option
• Precisions: fp32, fp16 and int16; the int16 build is the one that runs on the NPUs

Super-resolution 2x upscaling using Polaris's own UpscaleNet, a residual U-Net architecture trained on real astrophotos and designed for NPU-friendly int8 quantization. Useful for preparing images for large prints, high-DPI displays, or recovering more detail at the pixel level.

• Polaris UpscaleNet: custom residual U-Net; internally 2x-upsamples before the encoder, so the network processes the full high-resolution feature space
• Evaluated at 50.22 dB PSNR: fp16 (50.22 dB) is indistinguishable from fp32 (50.21 dB); int16 within 0.03 dB
• int8 via QAT: Quantization-Aware Training brings int8 back to near-lossless after PTQ showed a 3.3 dB degradation
• 2x scale: output is double the input dimensions in both axes; a 3000x2000 frame becomes 6000x4000
• Where: AI Tools toolbar and the Editor's AI section, Upscale option
• Precisions: fp32, fp16, int16 and an int8 build produced by Quantization-Aware Training, at 19 MB the smallest model Polaris ships