Astrogirl.au

Stacking is where your hours of exposure finally come together, it’s the moment faint photons become a visible nebula. But the integration settings you choose can make or break that delicate signal. Let’s walk through the key options in PixInsight’s WeightedBatchPreprocessing (WBPP) and how to optimize them for different targets.

Understanding the Core Settings

Calibration Exposure Tolerance

• What it is: Calibration frames (bias, darks, flats) must match your light frames. Exposure tolerance tells WBPP how much difference is acceptable.
• Why it matters: If tolerance is too strict, WBPP rejects good calibration frames. If too loose, it may apply mismatched calibration frames, adding noise.
• Recommended: 4–6 seconds for most setups
• Higher (8–10) only if your calibration library has mixed exposures.

Linear Defects Correction

This is a tool that removes defective rows or columns caused by sensor manufacturing imperfections. These defects show up as faint vertical or horizontal streaks in your final stack if not corrected.

• Recommended: Enable it with Rows and a limit of 5 for most modern cameras.
• Why it matters: It cleans up sensor artifacts before stacking, preventing streaks in your final image.

Subframe Weighting

• What it is: PixInsight scores each subframe based on quality — sharpness, noise, star shape — and uses those scores to decide how much each frame contributes to the final stack.
• Why it matters: Good subs should influence the final image more than bad ones. Weighting ensures faint signal isn’t dragged down by noisy or blurry frames.

Weighting options:

• PSF Signal Weight (Best for faint nebula & galaxies) Uses star sharpness and background noise to judge quality. PSF = Point Spread Function, a measure of star shape.
• PSF SNR (Best for bright nebula) Focuses on signal‑to‑noise ratio. Good when your target is bright and SNR is high.
• PSF Scale SNR (Best for dusty nebula) Adds FWHM (star size) into the equation. Great when seeing varies.
• SNR Estimate Simple global noise estimate. Fine, but less precise.

Local Normalization

• Purpose: Balances background brightness between subs.
• Always enable
• Why: If transparency changes, moonlight increases, or thin clouds pass through, your subs will have different background levels. Local Normalization fixes this so faint nebula doesn’t disappear under uneven sky glow.

Astrometric Solution

• Purpose: Ensures precise alignment and plate solving.
• Enable it: Especially useful for mosaics or multi‑night data.

Image Integration: what combination is and best methods

What “combination” actually does

You’ve got a stack of aligned images. For each pixel position, say, the pixel at (x, y), PixInsight looks at all the values from every subframe:

$$p_1,p_2,p_3,\dots ,p_N$$

Combination is simply: how do we turn those $N$ values into one final value?

Different methods answer that question differently, and that changes how much signal you keep and how much noise you reduce.

Average (mean) — the workhorse for deep sky

What it does:

For each pixel:

$$p_{\text{final}}=\frac{p_1+p_2+\cdots +p_N}{N}$$

You literally add all the pixel values and divide by the number of frames.

Why it’s so good:

• Noise reduction: Random noise tends to cancel out when averaged. The more frames you stack, the more the noise shrinks.
• Signal retention: Real signal (like nebula, galaxy light) is consistent across frames, so it adds up and survives the averaging.

The key relationship:

$$\text{SNR}\propto \sqrt{N}$$

Double the number of subs → about 1.4× better SNR. Stack 4× more subs → about 2× better SNR.

Impact on faint nebula:

Faint nebulosity is just barely above the noise floor. Average stacking lets that tiny signal accumulate while the random noise averages down. That’s why Average + good rejection is the gold standard.

Weighted average — the smart version of average

PixInsight often uses a weighted average under the hood when you enable weighting:

$$p_{\text{final}}=\frac{w_1{p}_1+w_2{p}_2+\cdots +w_N{p}_N}{w_1+w_2+\cdots +w_N}$$

Where $w_i$ is the weight of frame $i$.

What weights do:

• Good frames (sharp stars, low noise) get higher weights
• Bad frames (poor seeing, clouds, high noise) get lower weights

So the final pixel value is dominated by your best data.

Why it matters:

For faint nebula, a few noisy subs can drag the whole stack down. Weighted average lets PixInsight say: “These 10 subs are clean and sharp; these 3 are mushy and noisy—let’s listen more to the good ones.”

Median — the “middle value” (and why it’s bad for faint stuff)

For each pixel, PixInsight sorts the values:

$$p_{(1)}\le p_{(2)}\le \cdots \le p_{(N)}$$

Then picks the middle one:

• If $N$ is odd: $p_{\text{final}}=p_{(\frac{N+1}{2})}$
• If $N$ is even: average of the two middle values

What this does in practice:

Median is fantastic at rejecting outliers. If one frame has a cosmic ray or satellite trail, that pixel is way brighter than the others—median just ignores it.

But there’s a catch.

Why median hurts faint nebula:

Faint nebulosity is only slightly brighter than the background noise. When you sort the pixel values, those faint signals are not dramatically different from noise—they’re just a bit higher.

Median doesn’t “add up” signal like average does. It just picks the middle value. So:

• Noise doesn’t shrink as much
• Faint signal doesn’t build up
• The stack looks cleaner in terms of outliers, but low‑level nebulosity is suppressed

That’s why median is not recommended for faint targets. It’s like asking, “What’s the typical value?” instead of “What’s the accumulated signal?”

Minimum and Maximum — extremes, not for deep sky

For each pixel:

• Minimum: $p_{\text{final}}=\min (p_1,\dots ,p_N)$
• Maximum: $p_{\text{final}}=\max (p_1,\dots ,p_N)$

These are almost never used for astrophotography stacking.

Minimum:

• Picks the darkest value
• Great for making masks or special effects
• Terrible for signal—throws away all brighter contributions

Maximum:

• Picks the brightest value
• Keeps every cosmic ray, satellite, and hot pixel
• Completely unusable for clean deep‑sky images

Why average + rejection is the sweet spot

On its own, average will keep everything—signal and outliers. That’s why we pair it with pixel rejection:

• Average builds up signal and reduces random noise
• Rejection algorithms (like Winsorized Sigma Clipping) remove non‑random junk: satellites, cosmic rays, hot pixels

So the workflow is:

1. Align all subs
2. Normalize brightness
3. Weight subs by quality
4. Average the pixel values
5. Use rejection to throw away outliers

This gives you:

• Maximum SNR
• Minimum artifacts
• Preserved faint nebulosity

Concrete example: faint nebula pixel

Imagine a pixel in a faint Ha nebula region. Across 10 subs, its values (in arbitrary units) might be:

$$[1020,1015,1022,1018,1017,1021,1019,1016,1020,1018]$$

Background noise might be around 1000–1010.

• Average:

$$p_{\text{avg}}\approx 1018$$

You’ve clearly separated it from the background.

• Median:

Sorted:

$$[1015,1016,1017,1018,1018,1019,1020,1020,1021,1022]$$

Middle values ≈ 1018–1019 → similar, but as you add more frames, average keeps pushing the signal up relative to noise; median doesn’t accumulate signal in the same way.

Now add a cosmic ray in one frame:

$$[1020,1015,1022,1018,1017,1021,1019,1016,1020,5000]$$

• Average without rejection:

$$p_{\text{avg}}\approx \frac{1020+\cdots +5000}{10}\approx 1400$$

Ruined.

• Average with sigma clipping:

Rejection throws out 5000 → back to ~1018.

• Median:

Middle value still ~1018, cosmic ray ignored automatically.

So median is naturally robust to outliers—but at the cost of not truly building up faint signal over many frames. Average + rejection gives you both: outlier removal and signal accumulation.

Best settings for everyday stacking

• Combination: Average
• Rejection algorithm: Winsorized Sigma Clipping
• Normalization: Additive + Scale
• Low/High Sigma: Start around 2.5 / 3.0
• Why: This combo keeps faint signal intact while rejecting cosmic rays, satellites, and hot pixels.

Optimizing for Different Targets

Target Type	Integration Strategy	Notes
Faint Nebula (e.g. SH2‑240, IFN)	Winsorized Sigma Clipping + PSF Signal Weight + Local Normalization	Long total exposure (10 h+). Dither every few frames. Avoid median stacking — it kills faint signal.
Bright Nebula (e.g. Orion, Carina)	Linear Fit Clipping + PSF SNR	Transparency can vary; Linear Fit handles brightness shifts. You can relax sigma thresholds slightly.
Dusty Nebula / Reflection Nebula (e.g. VdB series)	Winsorized Sigma Clipping + PSF Scale SNR	Dusty regions are subtle — prioritize sharp subs and consistent color balance.
Galaxies	Winsorized Sigma Clipping + PSF Signal Weight	Galaxies benefit from high SNR weighting; drizzle if undersampled and dithered.
High Light Pollution	Local Normalization + Linear Fit Clipping	Helps equalize gradients and reject glow. Consider gradient removal before stretching.

Extra Tips for Cleaner Stacks

• Dither religiously: Every few frames. It’s the single most powerful way to fight pattern noise.
• Use noise‑based weighting: Let PixInsight decide which subs contribute most.
• Don’t over‑reject: Aggressive sigma clipping can erase real faint detail.
• Calibrate flats carefully: Uneven flats can introduce gradients that mimic nebulosity.
• Drizzle only if undersampled: It improves resolution, not faint signal strength.