Jeffrey Baltus Astro

Stacking and Post Processing

This guide is a high-level introduction to stacking and post processing individual deep sky object images using either free or paid software. Both of these methods follow my PixInsight (or PixInsight equivalent) workflow for OSC images, which is just one of many potentially “correct” ways to do it (see this comment from PixInsight forum user fredvanner). Note that these workflow can be followed with any equipment, from smart telescope to untracked DSLR to full dedicated astrophotography rig.

Sections on this page include:

The exact same sample demo data I acquired of the Pleiades (M45) are used throughout these tutorials, which can be downloaded here. Information about the equipment and full imaging session details (for all nights) can be found here. (Note: only 1 night of data from that full imaging session is used in this demo for simplicity and a smaller download file.)

Finally, these tutorials were created in August 2026, and the following software versions were used. if there are significant changes (especially if new PixInsight tools change my primary workflow), then this tutorial may be redone to stay somewhat current.

  • Siril: 1.4.4
  • Naztronomy OSC Pre Processing: v2.0.3
  • GraXpert: v2.0.3
  • StarNet++: v2.0.2
  • PixInsight: 1.9.4
  • RCAstro tools:
    • BlurXTerminator: 2.0.4 (AI version 4)
    • StarXTerminator: 2.3.11 (AI version 11)
    • NoiseXTerminator: 2.3.3 (AI version 3)

Note: if you have any issues, feel free to send an email (jbaltusastro@gmail.com) and I will help as I am able.

Software Download Locations

Note: I do not explicitly show how to install these in this already long webpage, but there are plenty of tutorials that you can find how to do it.

Stacking (Free Software Version: Siril)

First, Siril uses a “home directory” to identify where files are and where to save them. Click on the blue button on the top and navigate to where you saved the demo data. Click the “Open” button on the bottom right of the pop-up screen.

The easiest method for stacking in Siril in my opinion is to use the Naztronomy “OSC Image Preprocessor” script (v2.0.3 as of writing this tutorial), which is a very easy and intuitive tool to use. Details/information for the script (including a linked YouTube tutorial from Naz) can be found here.

Here is a screenshot of the final status of this for my demo data after adding the lights, darks, flats, and biases:

The only settings I initially recommend changing on the “2. Processing” tab are to always do a 1x drizzle amount (here with a pixel fraction of 0.90 px) to sharpen the stacked image and checking the box for “Save calibrated lights”. This script does include other additional “post processing” steps, but in the interest of this tutorial being for beginners and that I go through a full post processing workflow below, I will recommend that these initially be skipped. (Once you gain experience with astrophotography, I highly encourage you to learn more about the settings included in this script, including doing 2x drizzle if your image scale is undersampled.)

Then, you’ll just want to click the “Start Processing” button at the bottom.

It may take a while for your computer depending on how many files you have and how good your computer is (larger amounts of RAM help significantly; my laptop took just over 5 minutes to stack this demo data), but that’s it. Thanks to Naz, stacking images is incredibly easy in Siril. From here, move below to the Post Processing with free software section to further process the image…

Stacking (Paid Software Version: PixInsight)

Similar to the Siril tutorial above, there is an excellent tool within PixInsight called WeightedBatchPreProcessing (WBPP) that is fairly easy to use for stacking images.

First, if using darks (which are included in this demo data tutorial, even though I no longer actually use them with my camera), open the CosmeticCorrection process and update “Hot Sigma” under “Use Auto detect” to a value of 3.0. Then drag the triangle in the bottom left onto the PixInsight background to create a template. This will be used in the WBPP process. (You may want to rename that template as well, such as simply “CC”.)

For beginners using WBPP for the first time, I suggest a basic workflow using mostly default/basic options, shown in the screenshots below for each tab (Lights, Calibration, Post-Calibration, and Pipeline):

Lights Tab (with Astrometric Solution values updated):

Calibration Tab (with automatic cosmetic correction turned off and the template applied):

Post-Calibration Tab (with 1x drizzle applied):

Pipeline Tab (be sure to update the “Output Directory” in the bottom right for where files are saved):

From there, click “Run” and “Continue” on the next pop-up screen. You’ll be able to monitor the status of the stacking with the WBPP Execution Monitor:

Notice that this took over 1.5 hours to run on my laptop, way longer than the same data in Siril. However, I do think that PixInsight’s WBPP outperforms Siril stacking, though that is my purely subjective opinion. Computers with better performance (in particular higher RAM) will do this stacking faster in WBPP.

For an amazing free deep dive into WBPP and how each setting affects the stacking process, watch this playlist from Dr. Adam Block. I will note that generally I do not adjust most settings for my own image stacking, but it is great knowledge to have in case you have to debug/troubleshoot issues.

Post Processing (Free Software Version: Siril and GraXpert)

As I use PixInsight for processing my actual images, this Siril tutorial workflow mimics my PixInsight workflow as best as possible with free software only. For the reasoning why each step is done in the order I do them, see the first paragraph in the next “Post Processing (Paid Software Version: PixInsight and RCAstro Plug-Ins)” section for post processing with PixInsight.

Further, the steps below use default values that likely are not optimized for the data you’re using. Again, this is supposed to be a beginner only tutorial, but you should try a few different settings throughout most steps to see what works best with your data.

Load Image: If you are post processing immediately after stacking completed, your stacked image should appear automatically. If not, then you’ll simply need to load it at this point. (And if you had issues stacking, you can download the Siril stacked image here.)

After it loads it should look something like this, which is an unstretched image and thus very dark:

AutoStretch Preview: First, we will want to more easily see the image we’re working with. On the bottom, change the view from “Linear” to “AutoStretch” and make sure the “channel link” just to the right of it is unchecked (i.e., gray) for now. This doesn’t actually change the data in the image itself, just how we’re viewing it. (We will actually change the data via stretching and color calibration later on.)

Cropping: Looking around the edge of the image, you’ll see dark portions (in the corners) and odd looking artifacts. This is normal with astrophotography images during stacking and we simply need to crop that out. Go to “Image Processing > Geometry > Rotate&Crop”. Drag the edges as much as needed to remove those artifacts. Click “Apply”.

Star Correction: we will first do some corrections to the stars to get rid of some imaging and stacking artifacts to make them more round without coma or bloating. Go to “Scripts” and find the “GraXpert-AI.py” script that was downloaded and added to Siril. In it, begin by applying these default settings using the “Deconvolution (Stellar)” operation:

Gradient Removal: From here, we’ll want to remove the background gradient in the image. Again using GraXpert, use the “Background Extraction” operation:

From the earlier image (just after the AutoStretch preview step) we saw a strong light gradient from the bottom left. That is now gone (and what is left is actually some of the dust surrounding M45).

Plate Solve: before we can do a color calibration, we likely need to plate solve again after the earlier cropping. Go to “Tools > Astronomy > Image Plate Solver”. Enter the object in the search box (so the Right Ascension and Declination coordinates are accurate) and update the parameters for focal length and pixel size, if necessary. Click OK.

Spectrophotometric Color Calibration: we can see how the image still looks a little green from the camera sensor’s bayer pattern and (currently) inaccurate white balance, so we have to do a color calibration. Go to “Image Processing > Color Calibration > Spectrophotometric Color Calibration”. Be sure to pick the appropriate sensor, which for the demo data it is the IMX571 (for the ASI2600MC Air).

After re-enabling the linked channels (near the AutoStretch preview at the bottom, which we had earlier disabled), the image looks much better and has the correct color.

Deconvolution: to bring out extra detail and make the deep sky object sharper, a process called deconvolution can be used. Again using GraXpert, use the “Deconvolution (Objects)” operation using the default values for now. (FYI, the differences in the image after this process will be subtle.)

Star Removal: before actually stretching the data, it is best to remove the stars so that we can adjust the nebulosity (or galaxy) and stars separately. To do this, use StarNet++ by going to “Image Processing > Star Processing > StarNet Star Removal”. This will create two separate images saved in your Home location. (Note: you may need to rerun this with “Upsample x2” checked for best results, though I did not do so with this demo data.)

This will then open the starless image in the Siril window, which we will further process. (Note: some “star artifacts” may still appear, such as in the top left of my example image. This may end up better using the “Upsample x2” option, but this isn’t a bad result by any means.)

Stretching: switch the preview back to “Linear” (at the bottom) and then we’re ready to actually stretch the image using “Image Processing > Stretches > Generalized Hyperbolic Stretch Transformations”, which I believe provides the best flexibility and results. To understand what is meant by stretching the data, see this video from Dr. Adam Block; and to understand the methodology for Generalized Hyperbolic Stretch, see this video also from Dr. Adam Block. (That latter video uses PixInsight, but the stretching methodology holds for Siril too.)

First, with a “Linear stretch (BP shift)”, move the histogram to the left by adjusting the black point to ensure we utilize the full dynamic range available:

Second, set a symmetry point about halfway up the left side of the current histogram curve. Use the stretch factor and local stretch intensity to move the actual histogram to be about one fourth to one third of the way from the left when zoomed out. This is the first stretch of the actual image.

Third, do another stretch to bring out more contrast among the nebulosity (or galaxy). Pick a symmetry point that is just to the right of the main histogram (which is essentially where the dark sky/background and the nebulosity or galaxy meet on the histogram). Then gently use the stretch factor and local stretch intensity to adjust until you see the contrast you desire.

A final stretch may be needed if the background seems to be too dark. (The sky background should never be pitch black.) Do this by choosing a symmetry point in the middle of this histogram curve and slowly adjust the stretch factor and local stretch intensity. Note: I did not do this step with this demo data tutorial as this initially looked ok to me.

Noise Reduction: at this point with the starless image, we use GraXpert again to remove some noise. Do not do this too strongly or the image will have a plastic/fake look to it.

Recombine Starless and Star Images: The final step to this basic workflow is to recombine the starless and star images. Be sure to first save the denoised starless image so that progress is not lost if this step goes awry. Then, use “Image Processing > Star Processing > Star Recombination”. Add in your starless and star (i.e., “starmask”) images and adjust the sliders as needed to get the resulting image to how you desire. When you’re happy with what the image looks like, click Apply.

My final image with this demo data tutorial (the file can then be saved from Siril):

In retrospect, if I were to spend a lot of time on this I would have optimized settings for this data and would have stretched this data way more to bring out even more dust surrounding M45. But, for this being a basic demo tutorial, this turned out just fine.

Post Processing (Paid Software Version: PixInsight and RCAstro Plug-Ins)

Before getting into the actual tutorial, it’s important to discuss why some steps need to occur in a specific order at the very beginning of the post processing workflow. For example, deconvolution should never be performed after noise reduction as it can introduce artifacts that do not exist within the raw image data. Here are the first few steps that I do every time and why:

  • BlurXTerminator with Correct Only
    • Per vicent_peris, a valid workflow would be BlurXTerminator > SPFC > MGC > SPCC.
    • Per Juan Conejero, PixInsight uses this “Correct Only” step in the creation of the MultiscaleGradientCorrection tool (which is used for correcting the background and gradients in the image).
  • SpectrophotometricFluxCalibration (SPFC)
    • Per previous links, this is needed to do MGC.
  • MultiscaleGradientCorrection (MGC)
    • Previously I used to sometimes use GradientCorrection when MGC didn’t have sky coverage for my object, but this is no longer needed in the northern hemisphere. However, I want to mention that this (GradientCorrection) was chosen over DynamicBackgroundExtraction (DBE) as per Juan Conejero the “tools based on placing samples on the image are now obsolete.”
  • SpectroPhotometricColorCalibration (SPCC) with a preview to also run background neutralization
    • This corrects the white balance of the 3 channels (red, blue, and green) and should generally be one of the first steps. (Example thread, though SPFC > MGC > SPCC is a newer valid workflow.)
  • BlurXTerminator
    • In this video, Adam Block talks with Russell Croman about workflows with BlurXTerminator. In it, he explicitly says to do SPCC prior to BlurXTerminator and prior to NoiseXTerminator.
  • StarXTerminator
    • In the usage notes, it says to “use StarXTerminator as early in the processing flow as possible, ideally right after integration, with the data still in a linear state (i.e., prior to any stretching). This will generally produce the best results, and gives the added flexibility of being able to stretch the starless and stars images separately depending on the desired end result.”

PixInsight is not as straightforward to use as Siril when it comes to applying tools/processes to the image. To become familiar with PixInsight, I suggest watching some videos from this playlist by Dr. Adam Block. (Some of those videos are no longer relevant due to better tools/processes now available, but they still help when getting familiar with navigating and using PixInsight.)

Further, the steps below use primarily default values that likely are not optimized for your specific data. This is supposed to be a beginner only tutorial, but you should try a few different settings throughout most steps to see what looks best with your data.

Load Image: The file from WBPP was saved in your specified “Output Directory” under the “master” subfolder with a suffix of “…_drizzle_1x_autocrop.xisf” (xisf is effectively PixInsight’s FIT file equivalent). If you had issues with WBPP, you can find my PixInsight stacked file here.

When the file is opened, you’ll see two “images” in PixInsight, but one will be completely black as it is a “crop mask” to show how much of the file was autocropped. That image is not needed and can be closed. Here’s the unstretched image:

AutoStretch Preview: First, we will want to more easily see the image we’re working with. The quickest way to do an “unlinked autostretch preview” is by holding CTRL (on Windows) and left clicking on the STF AutoStretch button at the top right. This doesn’t actually change the data in the image itself, just how we’re viewing it. (We will actually change the data via stretching and color calibration later on.)

Notice how this appears rotated compared to the image from Siril demo. That is strictly due to what image was picked as the reference image during stacking and has no real other effect. If you want to change this rotation or do a further crop of the image, you can use the respective Rotation or DynamicCrop processes. I did not do so for this demo.

Star Correction: using BlurXTerminator, run this as “Correct Only”. Apply it by dragging the triangle in the bottom left onto the image.

Gradient Removal: a new PixInsight process has been added that greatly improves gradient removal. First, you will need to run SpectrophotometricFluxCalibration (the default settings shown in the screenshot are appropriate for the camera used in this demo) with the triangle drag-and-drop method. Then, close the pop-up graph from that and run MultiscaleGradientCorrection with the triangle drag-and-drop method.

Do an AutoStretch preview on the new “gradient_model” image to make sure that the nebulosity (or galaxy) did not have a significant amount removed through this tool. In this case, it does appear that some of the central nebulosity was removed, so I normally would undo this change to the main image and then increase the “Gradient scale” parameter to the next largest setting and repeat until I was satisfied. (Note: I did not redo this step with an increased “Gradient scale” parameter in this demo.)

Spectrophotometric Color Calibration: we can see how the image still looks a little green from the camera sensor’s bayer pattern and (currently) inaccurate white balance, so we have to do a color calibration. First, create a small preview and place it on the background (where no or very little nebulosity is located). Add that preview as the “Region of Interest” for the “Background Neutralization”. Apply this to the image with the triangle drag-and-drop method.

Do a “linked autostretch preview” by holding Shift (on Windows) and left clicking on the STF AutoStretch button at the top right.

Deconvolution: to bring out faint details and make the deep sky object sharper, a process called deconvolution can be used. Use BlurXTerminator with the triangle drag-and-drop method.(FYI, the differences in the image after this process will be subtle.)

Star Removal: before actually stretching the data, it is best to remove the stars so that we can adjust the nebulosity (or galaxy) and stars separately. To do this, use StarXTerminator with the triangle drag-and-drop method. This will create two separate images on the window. (Note: you may need to rerun this with “Large Overlap” checked if, for example, significant nebulosity/galaxy artifacts seem to have been included in the new star image, though I did not do so with this demo data especially because the reflection nebula around the M45 star cluster are very difficult to truly parse apart and StarXTerminator did a great job already.)

Stretching (Stars): there are many methods people can use for stretching the star image. I prefer to keep it very simple by using the ScreenTransferFunction and HistogramTransformation. Open both tools, click on your star image, and then within each of the tools click the checkmark on the bottom right to ensure that they are tracking the star image. Drag and drop the triangle from the ScreenTransferFunction process to the bottom bar of the HistogramTransformation process. You should see the an hourglass and the icon in the screenshot below, then release. This adjusts the HistogramTransformation, which we then apply to the star image using the HistogramTransformation triangle drag-and-drop method.

You’ll see the image become extremely bright, which is only because we’re essentially applying the autopreview twice. To remove this “issue”, simply click the reset button at the bottom right of both the ScreenTransferFunction and HistogramTransformation processes.

To do a “star reduction” (if you’d like fewer or less prominent stars in the later combined image), I simply move the midpoint slider on the ScreenTransferFunction to the right (shown below), then do the same method as previously to apply it to HistogramTransformation and then from HistogramTransformation to the star image.

Stretching (Starless): another relatively new process by PixInsight makes stretching the starless image incredibly easy: MultiscaleAdaptiveStretch. First, reset the autostretch preview by clicking the Reset Screen Transfer Functions button on the top right.

Then open MultiscaleAdaptiveStretch and apply the previous preview that we created to the the Background Reference parameter. Click the open circle on the bottom left of this process to see the “Real Time Preview”. From here, make a few adjustments to this until you are happy with the resulting image and then apply this using by clicking the square button on the bottom left of the process. You can then close out the Real Time Preview screen and the MultiscaleAdaptiveStretch process.

Typically at this stage I will use CurveTransformation to adjust the contrast and saturation a bit further, but I have not done so in this demo. (I also usually adjust the saturation to be slightly greater in the star image with CurveTransformation, which is also not done in this demo.)

Noise Reduction: at this point with the starless image, we use NoiseXTerminator to remove some noise. Do not do this too strongly or the image will have a plastic/fake look to it.

Recombine Starless and Star Images: The final step to this basic workflow is to recombine the starless and star image. First, rename each of the two images to be “stars” and “nebula” (or “galaxy”), respectively. This simply helps when we use the PixelMath process with this equation: combine(nebula, stars, op_ screen())

Before applying this with the square button (bottom left), I highly recommend using the “Create new image” setting below:

My final image with this demo data tutorial (which can then be saved):

As mentioned before, some of these settings may need to be adjusted to optimize them for your image. Further, masks may be needed to help process certain parts of the image while others remain unaffected; however, as great as masked adjustments are, I try to stick to these steps as much as possible and simply rely on good data instead of using advanced processing “tricks”.