Which formula do you recommend to recombine stars with starless nebula with PixelMath?

Processing Deep Sky
23 replies•4.4k views
Daniel Arenas avatar
Daniel Arenas avatar
Hi everyone!

I would like to improve more the way I use PixelMath to recombine Stars with Starless frames after being processed separately. I used to add them with a basic formula like: 

stars + starless

But I think that maybe is the worst way to do, or at least the less accurate way.

Would you mind recommending me other formulas? Or which one do you use?

Many thanks and clear skies! ;)
Engaging
Dieter Wiedenhofer avatar
Dieter Wiedenhofer avatar
HI, try this one, it works good

combine(Starless,Stars,op_screen())

CS, Dieter
Daniel Arenas avatar
Daniel Arenas avatar
Dieter Wiedenhofer:
HI, try this one, it works good

combine(Starless,Stars,op_screen())

CS, Dieter

Thanks a lot, Dieter!

What does "op_screen()" means?

I'll try it ;)
John Hayes avatar
John Hayes avatar
Why do you think that stars+starless might be the worst way to combine the data?  In principle, the algorithms that separate out the stars should be producing two images that add to the original.  The only question might be how the algorithm is handling the background so that the sum of the two images produces the same background statistics as the original.  I've always just added the stars to the starless and it appears to work quite well.  I've never taken the time to investigate the background statistics but on first inspection the result always looks like a "reasonable" combination.  Maybe there's some nuance about matching the mean background levels that might improve the statistics a bit but again, I've never fiddled around with that idea.

John
Well Written
Andreas Zeinert avatar
Andreas Zeinert avatar
When using StarXterminator I use ~((~starless)*(~stars)). This is recommended by the script and works very well. Be careful on tiny background galaxies which might be taken for stars, you might have problems to reveal them afterwards.=MsoNormalAnother formula is  : a*(1-(1-top)*(1-bot)) + (1-a)*bot, a = [0,1]  bottom = starless images top = star image.
Daniel Arenas avatar
Daniel Arenas avatar
John Hayes:
Why do you think that stars+starless might be the worst way to combine the data?  In principle, the algorithms that separate out the stars should be producing two images that add to the original.  The only question might be how the algorithm is handling the background so that the sum of the two images produces the same background statistics as the original.  I've always just added the stars to the starless and it appears to work quite well.  I've never taken the time to investigate the background statistics but on first inspection the result always looks like a "reasonable" combination.  Maybe there's some nuance about matching the mean background levels that might improve the statistics a bit but again, I've never fiddled around with that idea.

John


Hi John,

Just because it seems a too easy formula and because i've read that people use a lot of varieties to solve some kind of problems of bright when add the two data.
But I'm totally ignorant on this.
Die Launische Diva avatar
Die Launische Diva avatar
John Hayes:
Why do you think that stars+starless might be the worst way to combine the data?  In principle, the algorithms that separate out the stars should be producing two images that add to the original.  The only question might be how the algorithm is handling the background so that the sum of the two images produces the same background statistics as the original.  I've always just added the stars to the starless and it appears to work quite well.  I've never taken the time to investigate the background statistics but on first inspection the result always looks like a "reasonable" combination.  Maybe there's some nuance about matching the mean background levels that might improve the statistics a bit but again, I've never fiddled around with that idea.

John

Because people tend to process stars and starless images differently, thus altering the luminances of both images in a non-linear fashion. By simply adding back a processed starless images you may push the stars to RGB values dangerously close to one. And by the way, this is the advice given by the author of starXterminator: https://pixinsight.com/forum/index.php?threads/unscreening-and-re-screening-recombining-stars-with-starless-images.18602/
Daniel Arenas avatar
Daniel Arenas avatar
Andreas Zeinert:
When using StarXterminator I use ~((~starless)*(~stars)). This is recommended by the script and works very well. Be careful on tiny background galaxies which might be taken for stars, you might have problems to reveal them afterwards.=MsoNormalAnother formula is  : a*(1-(1-top)*(1-bot)) + (1-a)*bot, a = [0,1]  bottom = starless images top = star image.



Many thanks Andreas,

Yes I've used StarXterminador to separate stars and starless and I use it with the box "large overlap" checked.

Daniel.
Arun H avatar
Arun H avatar
John Hayes:
In principle, the algorithms that separate out the stars should be producing two images that add to the original.


Is this actually correct? Because the original image contains no information on what is behind the rendition of the star, which is of non zero size due to diffraction and seeing effects. My impression always was that the program was filling the space occupied by the star with some sort of interpolated content which is not how the original image was constructed, hence a simple addition could not recover the original image. Plus the points that Die Launische Diva made above.
dkamen avatar
dkamen avatar
Arun H:
John Hayes:
In principle, the algorithms that separate out the stars should be producing two images that add to the original.


Is this actually correct? Because the original image contains no information on what is behind the rendition of the star, which is of non zero size due to diffraction and seeing effects. My impression always was that the program was filling the space occupied by the star with some sort of interpolated content which is not how the original image was constructed, hence a simple addition could not recover the original image. Plus the points that Die Launische Diva made above.

Hi,

starnet2 is designed so that stars+starless=original.  You can actually see the tiny holes corresponding to (already saturated) star cores if you zoom in on the starless image.

Cheers,

D.
Well Written Helpful Insightful Respectful Concise Engaging
Miguel G. avatar
Miguel G. avatar
Die Launische Diva:
John Hayes:
Why do you think that stars+starless might be the worst way to combine the data?  In principle, the algorithms that separate out the stars should be producing two images that add to the original.  The only question might be how the algorithm is handling the background so that the sum of the two images produces the same background statistics as the original.  I've always just added the stars to the starless and it appears to work quite well.  I've never taken the time to investigate the background statistics but on first inspection the result always looks like a "reasonable" combination.  Maybe there's some nuance about matching the mean background levels that might improve the statistics a bit but again, I've never fiddled around with that idea.

John

Because people tend to process stars and starless images differently, thus altering the luminances of both images in a non-linear fashion. By simply adding back a processed starless images you may push the stars to RGB values dangerously close to one. And by the way, this is the advice given by the author of starXterminator: https://pixinsight.com/forum/index.php?threads/unscreening-and-re-screening-recombining-stars-with-starless-images.18602/

that's it
Miguel G. avatar
Miguel G. avatar
I, by the way, use the above formula ~((~starless)*(~stars)). I don't fully get the logic behind it, but it's in fact one formula that the creator of starxterminator recommends in his own module tooltip:



I've also used combine(starless,stars,op_screen()), but less often
John avatar
John avatar
Daniel Arenas:
Hi everyone!

I would like to improve more the way I use PixelMath to recombine Stars with Starless frames after being processed separately. I used to add them with a basic formula like: 

stars + starless

But I think that maybe is the worst way to do, or at least the less accurate way.

Would you mind recommending me other formulas? Or which one do you use?

Many thanks and clear skies! ;)

You need to do a linear fit first,so you dont get rings around the stars.
John Hayes avatar
John Hayes avatar
Die Launische Diva:
John Hayes:
Why do you think that stars+starless might be the worst way to combine the data?  In principle, the algorithms that separate out the stars should be producing two images that add to the original.  The only question might be how the algorithm is handling the background so that the sum of the two images produces the same background statistics as the original.  I've always just added the stars to the starless and it appears to work quite well.  I've never taken the time to investigate the background statistics but on first inspection the result always looks like a "reasonable" combination.  Maybe there's some nuance about matching the mean background levels that might improve the statistics a bit but again, I've never fiddled around with that idea.

John

Because people tend to process stars and starless images differently, thus altering the luminances of both images in a non-linear fashion. By simply adding back a processed starless images you may push the stars to RGB values dangerously close to one. And by the way, this is the advice given by the author of starXterminator: https://pixinsight.com/forum/index.php?threads/unscreening-and-re-screening-recombining-stars-with-starless-images.18602/

Ah, thank you for that.  The key issues is in properly maintaining the star colors--not just normalization luminance to stay within the maximum intensity value.  When you separate the stars from the nebular you are indeed producing two images that add to the original but the star colors will be screwed up by the background color of the starless image.  So if you change the colors in either data set,  you have to create an un-screened version of the stars and then re-screen the two data sets to get a result with the correct colors, which makes perfect sense.  The reason that simply adding the two data sets has worked for me is that I've only replaced color-corrected white stars in an NB image with RGB stars and in that special case, adding white to the star colors simply desaturates the colors, which is easy corrected after doing the combination.  As I've pointed out, you also have to be careful about how the backgrounds combine but that's more an issue of making sure that you don't do anything "adverse" to either background before re-screening.  

John
Helpful Insightful Respectful Engaging
Nick Grundy avatar
Nick Grundy avatar
since i was testing this out a bit (although it's obviously dependent on the workflow) I tried out a few methods above to see if I could tell the difference. the "tilda" named image is the " ~((~starless)*(~stars))" method. Honestly, I'm not sure I can see it. 

I did use Starnet2 to create the starmask in case that impacts things. Seems like many of you all are using StarXterminator though

Die Launische Diva avatar
Die Launische Diva avatar
Nick Grundy:
since i was testing this out a bit (although it's obviously dependent on the workflow) I tried out a few methods above to see if I could tell the difference. the "tilda" named image is the " ~((~starless)*(~stars))" method. Honestly, I'm not sure I can see it.

It all depends on how much you process (stretch, saturate) your images prior to recombining them.
Nick Grundy:
I did use Starnet2 to create the starmask in case that impacts things. Seems like many of you all are using StarXterminator though

No. I suspect that many of us are great fans of Nikita Misiura's tools (StarNet, DeepSNR) because he has provided some insights on their implementation (and even some code), contrary to other DL-based products. For some of us, transparency on algorithms for astronomical image processing matters a lot (a lot more than the price).
Tim Hawkes avatar
Tim Hawkes avatar
starless + stars - starless * stars    works quite well when adding back RGB stars.  It  minimises the effect of the background on the star colour - especially if you slightly over-saturate the star colour before doing it.  There is a good discussion and further ideas here https://www.youtube.com/watch?v=hX3LKhwqwvY

So this below from the autrhor (Lamb) gives near perfect star colour retention but without any star saturation bloating

Jean-Baptiste avatar
Jean-Baptiste avatar
Whooaa !
I was thinking that this post would have already mentionned @Bill Blanshan  but this is not the case

As long as you are not in linear phase you have several point to reconsider for recombination, you can go for several directions with pros and cons on the final result 

Luckily, we have someone in our community who has deep dived this subject and who has a huge knowledge of Pixel Math : BIll Blanshan

He has defined a set of PixelMath formula which are the equivalent of script or processes, there are very easy to use and you can can look at the formula and its videos if  you want to understand what can be done (which I highly recommend, it is always better when you understand ^^); his formulas includes 4 ways to blend / add the images

go and see there, for me, it is a must if you are a PixInsight user :
https://www.youtube.com/channel/UCtxCDfyRToNx2s147fO2lxA/about

And regarding the various discussions on StarXterminator / starnet and what is the star-only version, here what I can say : 
- the process has been trained to create a starless image, period 
- with that image, you can produce a star_only image which is : 

A) the arithmetic difference : Image - StarlessImage
This is very usefull in linear phase but has limits because the star profile is then depending on the profil of the starless image
To be more precise, in linear, because the process is working only in non linear, when you click on "linear image" for a starless imagen the process is doing the following :
- automatic stretch of the image
- creation of starless image
- automatic "un stretch" of the starless image with inverse parameter of the initial automatic stretch
- arithmetic difference of the Image minus starless

B) you can try others formula such as a one wihch maintain the star profile, this is the "unscreen"
this is where you end up with another formula (the same that is used in StarXterminator for the unscreen feature)

All this is explained very well with the associated formulas in Bill vidéo, for the star shape, you will find this in another video : 
https://www.youtube.com/watch?v=rM3-yAcAbZc&t=0s (screen shot at 15'20")

you end up with the "unscreen" formula which is : ~(~Image/~StarlessImage)

these "star_only" image are just various possibilities based on the image and the starlessimage


Personnaly, in non-linear, for my "quick work" I used a simple addition with unscreen stars but I perform an un-stretch before and then I re-stretch, this allows to avoid clipping. 
This is very quick and It is enough when you don't touch too much the luminance : for exemple you separate, you perform a sharpening on the starless image and then you recombine

Instead of "Starless + Stars_only" you do something like :
mtf(0.001, (mtf(0.999, Starless) + mtf(0.999, Stars_Only)))

You just need to stretch in the complementary of the value you used for the "destretch", you could use :
mtf(~x, (mtf(x, Starless) + mtf(x, Stars_Only)))
where x = 0.999

If I want to do something more elaborate, I use Bill pixelmath ;-)

Clear skies
Dale Penkala avatar
Dale Penkala avatar
I personally use the same formula for adding my stars back in using the SXT formula and I have very good luck with it. I find it works really really well on RGB images. Combining RGB starless to RGB stars.

I know this is slightly off topic from the OP but, I’d like to add a variant to this a bit when you’re adding RGB stars to a NB Starless image. Back in September of last year there was a thread that was going about doing that and I got involved with it myself and found that this was excellent. It involves using the luminance layer of the NB stars and applying it back to the RGB star layer. I was pleased at how it worked that when I do the RGB stars to a NB starless image I follow this process. BTW it still uses the same “SXT” formula.

If you’re interested in that thread you can find it here. I think its an interesting read and maybe some of you might like to give it a try if your not already doing so: https://www.astrobin.com/forum/c/astrophotography/deep-sky-processing-techniques/an-excellent-method-of-blending-rgb-stars-with-a-narrowband-image/?page=1

Full disclosure, I’m far from being strong in the PM formulas so this was a great opportunity for me to improve my personal images.

Dale
Leonardo da Silva Garcia Leite avatar
Leonardo da Silva Garcia Leite avatar
Don't need to get fancy of you don't want to. 
star + starless works fine, although I also use 1 -(1-star)*(1-starless) for heavy star fields ~ is equal to 1-x. The most IMPORTANT thing is to control the curves of the star image. Stretch or unstretch it, so it fits your taste.

I usually have to try 2-3 different stretches so that the result in the pixel math come out good.
Rob Foster avatar
Rob Foster avatar
Hi Daniel,
Well I have certainly learned a lot reading the other responses in this post and look forward to trying some of them out. My approach probably oversimplifies things but seems to give consistent results and it has already been mentioned, and that is using the   "combine(ImageX,ImageY,op_screen())" formula. In the linear state, after DBE, SPCC, and BXT, I will separate out the stars using StarXTerminator. I then process and stretch separately.  For the stars, I almost always manually stretch carefully using HT paying careful attention to the biggest/brightest starts to make sure they are not blown out with a pink core in the stretched image. If so, I go back, use the HSV repair and ColorClip Script then restretch. The starless image is treated with NoiseXTerminator, then stretched a variety of ways, including Masked Stretch and a manual Histogram Stretch.  Stars are pretty much done at this point, but the starless image gets variably processed a bit more to bring out details/faint luminosity until I think it is close.  I use the formula combine(ImageX,ImageY,op_screen()) and cut and paste that exact formula into Expression Editor in PixelMath. I then highlight or select ImageX, then double click on the starless image from the image menu on  the right side of the Expression Editor to substitute it in; then highlight/select ImageY, and double click on the star image to substitute it in.  Going back out of Expression Editor, I change Destination to New Image and run the process.  This combines the two images using the screening operation.  This has worked well for most of images I have published, though I meant it when I said that there is a lot of great info in the other answers to this post that I look forward to trying. Good Luck!  Rob
Helpful
Rod Hughes avatar
Rod Hughes avatar
At first glance the PM formula : ~((~starless)*(~stars)) is confusing, but interesting. When 2 very large numbers are multiplied together, an even larger number is produced. What would happen if that even larger number was too large for the computer to understand? I don't know, but it probably isn't good.

The ~ character takes the inverse (1/x) of the pixel value and makes a small number that is used before multiplication. The first ~ in the formula takes the invers (1/x) of the multiplied result to arrive at the value we need. Its sort of like taking the inverse of an inverse, which is the original value. If a pixel value was 0, there would be a problem because the inverse of 0 is infinity, so PixelMath protects against that situation.

The formula, ~((~starless)*(~stars)), is clever to make sure the computed result doesn't cause a computer crash.
Helpful Insightful Respectful Engaging
Mike Cranfield avatar
Mike Cranfield avatar
Rod Hughes:
At first glance the PM formula : ~((~starless)*(~stars)) is confusing, but interesting. When 2 very large numbers are multiplied together, an even larger number is produced. What would happen if that even larger number was too large for the computer to understand? I don't know, but it probably isn't good.

The ~ character takes the inverse (1/x) of the pixel value and makes a small number that is used before multiplication. The first ~ in the formula takes the invers (1/x) of the multiplied result to arrive at the value we need. Its sort of like taking the inverse of an inverse, which is the original value. If a pixel value was 0, there would be a problem because the inverse of 0 is infinity, so PixelMath protects against that situation.

The formula, ~((~starless)*(~stars)), is clever to make sure the computed result doesn't cause a computer crash.

Just to clarify - the ~ character actually means "1 - ", i.e. ~x = (1 - x) not 1/x.

So in fact all four of the following expressions are mathematically identical:
  • ~((~starless)*(~stars))
  • 1 - ((1 - starless)*(1 - stars))
  • starless + stars - starless*stars
  • combine(starless, stars, op_screen())
Insightful Concise
Robert Shepherd avatar
Robert Shepherd avatar
Hi all,

I ran a side by side comparison between different star combination methods a while ago. You can find the results in the versions of the image:

https://astrob.in/9czvo5/0/

I hope this adds some value.

Cheers
Robert
Related discussions
Best way to add Ha data to LRGB in Pixinsight?
I'm new to PixInsight (one day in) and am trying to add Ha data to LRGB. The way I used so far was to use Pixelmath to work out the difference between the Ha data and the Red channel and create a a sudo-starless image like below: I then used Pixe...
Discusses PixelMath techniques for recombining processed frames, directly relevant to author's workflow.
Nov 13, 2021