Get a poster, t-shirt, mug, mousepad... with this image!

The strategy you choose to deal with gradients will depend on the image, how severe the gradients are, and your goals. This tutorial shows you how I deal with gradients with images that also contain very faint details in the background that I want to preserve.

Many people attack gradients somewhere in the middle of the processing of an image. While the results obtained by doing this can be ok, my experience is that it's a lot better to deal with the gradients at the very beginning.

There are many reasons why dealing with gradients in the middle of the processing is just not a good idea:  stretching an image with gradients is not desirable because our histogram isn't true to the data we want to process - the histogram is including the gradient data, which means we're looking at a histogram that is not a good representation of our data, and why would we want to carry the gradient data with us as we process the image and deal with it "later"? Also, color-balancing an image with gradients can be misleading, so again, ideally we want the gradients corrected before we color-balance our image, something that is better to do when the image is still linear - which also means our gradient corrections must not break the linearity of our image, they have to be done early in the process, etc. In short, gradients have been added to our image and they're unwanted, so before processing our image we should get rid of them first, and once that's done, proceeded as "usual".

The most effective way of removing gradients (other than perhaps super-flats?) is by creating a background model defining the gradient and subtracting it from our image. We subtract it because gradients are an additive effect. By doing this, we can remove the gradients and be left with an image that is still in linear form, so we can then start processing it just like we would with any image - but without gradients!

The Data

The captured data was of Ok quality, but as you will see, it wasn't free of gradients. The master file was generated from 7 subexposures of 15 minutes each at -20C temperature, with a SBIG STL11k camera and a Takahashi FSQ106EDX telescope with the 0.7x reducer. The data was captured at DeepSky Ranch, California, between 1:45am and 3:30am on May 6th, 2010.

The Goal

The goal in this session is to remove the gradients from the luminance, but at the same time trying to preserve some very VERY dim galactic cirrus that populates that area.

1 - Preliminary work

We want to see what's in there, so we use the "Auto" function from the ScreenTransferFunction tool (STF from now on) to perform a strong "screen stretch", that is, a strong stretch of the image as presented on the screen but without actually modifying any data in the image.

Now we can see what's really there, and the most noticeable thing (besides a "bad column" that wasn't corrected during calibration) is a gradient that presents our image rather bright on the left area, and much darker on the right. Our two globular clusters show nice and clear, which is nice.

If we pay very close attention, we also notice that there is in fact some data of the galactic cirrus in the image. We can tell the galactic cirrus from the gradient, because the gradient is a uniform and gradual effect across the image, but we can also see some structural differences. Yes, they're hard to see, but with some experience (and by looking at the actual image, not at a reduced screenshot) is quite noticeable. One thing is sure, we won't be able to do anything with that galactic cirrus unless we get rid of the gradient, and fast!

2 - Creating our background model

Our gradient is back, indeed. In this histogram stretch we can also better see some of the galactic cirrus data that we do NOT want to remove.

Now we use the DynamicBackgroundExtraction tool (DBE from now own) to construct the background model.

Although I am not going to use the DBE symmetry function, I like to set the symmetry point at a place that seems to make sense to me, all the way to the right of the image in this case.

VERY IMPORTANT: When placing the samples that later will be used to create the background model, first I will place just a few of them, at an average of perhaps just 5-8 across. The reason is twofold. First, we're trying to model a gradient, and gradients are usually very smooth and gradual. If we were to place many samples, our model will start not to be as smooth and gradual as the gradient, as I will show you in a minute. The other reason is that we want to preserve the very subtle differences in the galactic cirrus data in the background, and we definitely do not want the samples to catch these differences.

In the screenshot above you can (barely) see the sample points in cyan blue. Later you'll be able to see them much better, so I'll talk about that then.

The next step is to SAVE this process as a "Process Icon". The reason is, we do not want to apply the DBE to this non-linear image. We have stretched this image to get a better feel of where the samples should go. By saving the process, we can then apply it to our real "good" image later.

Notice in the screenshot above the little icon next to the mouse cursor. We've created this process icon by dragging the "blue triangle" at the bottom-left of the DBE dialog over the workspace.

3 - Applying the background model

We can now close the DBE dialog and the stretched image. After doing that, we double-click on the process icon, and we "magically" apply to our "good" image the parameters we just defined earlier:

Here is when I can better show you where I've placed my samples. Notice I first auto-generated about 6 samples per row (equal spacing vertically) and then I've placed a few samples manually on the left area, where I noticed there was a very "short" darkening gradient, that our model background wouldn't pick unless we also set a few more samples there. Generally, in order to protect the very faint background structures, we should do an even more careful placement of the samples across the image, but as we shall see, even a more general sample placement can yield good results.

With that done, we're ready to apply the DBE. Notice (if you can read it!) that I have selected "Subtraction" as the correction formula. As I mentioned earlier, gradients are of additive nature, so in order to correct them, we must subtract the background model, rather than dividing it (which is what we'd do if we were dealing with vignetting, for example).

And here's our corrected image after subtracting the background model created by the DBE process:

Not much to see, right? Let's now apply a STF to both, our corrected image and the background model. This allows us to see whether the gradient has been successfully corrected as well as the shape of the background model we've used:

On the left you see the background model. Notice it's a smooth and gradual model, which is exactly what we wanted. If we were looking for complete perfection, we do notice that there's a few areas in the model that don't seem to be "just gradient corrections". In that case we would go back to the DBE tool, readjust the position of our samples, perhaps also readjusting some of the modeling parameters, using as a guide the background model we just created - which "tells" us where it didn't do a good job.

On the right you see the corrected image (with a very strong STF stretch). We do notice the background is not perfectly flat. Did we fail? Nope, that's the signal from the galactic cirrus! Other than that, we can tell the gradient is pretty much gone.

We disable the STF and our image is ready to be processed. Just as when we started but without the gradient:

4 - Verifying faint background signal

Although we are confident that the uneven background signal we saw in the STF'ed image after applying our background model is not the result of gradients, in part because we were able to see that the differences in background brightness of the "screen-stretched" image do not correspond with the subtle differences we notice in our background model, a reassuring check would be to compare a quick non-linear stretch of our image with the same area from the IRAS survey, Here's our image:

And here's the same area from the IRAS survey:

Obviously our image does not offer the same level of detail - in some cases it might, once processed, but certainly not at this point where all we're doing to our image is just a screen stretch - but we can see that the background areas that appear to be darker in our image roughly match the darker areas in the IRAS image. To get an even closer picture, we can apply some multi-scale processing techniques (MS) to our image so we can bring out even more clearly the background signal - for this purpose we have also applied some strong histogram adjustments (HS) over-highlighting bright areas and over-darkening darker background areas:

As I think it's clear, our bright background structures match pretty well with the structures from the IRAS image. Of course they do NOT match exactly, that's why when making that assesment, we must consider a couple of things:

• We've just collected 7x15 minutes subexposures from a less than perfect sky, so the signal we've captured from the cirrus is not going to be as detailed as if we had imaged the Orion Nebula.

• The quick multi-scale process we've applied usually blurs the large scale structures - our purpose at this point is to identify whether bright intensities in the background we have now  more-or-less match the bright areas from the survey image, and blurred structures are ok to make that assesment. You can tell by looking at the final processed image that when processed carefully, the background structures don't look exactly like the "quick blur" we just did.

• The resolution and quality of the image we've obtained from the IRAS survey is also not ideal - areas that look very dark in the image may not be really absent from galactic cirrus for example. I have seen images taken with large telescopes of parts of the sky that display a large and dense amount of galactic cirrus where the images from the IRAS survey barely show any.

And of course, what really matters for the purpose of this tutorial is that the gradients we originally had in the image have no influence in this background signal, that we have been able to remove the gradients using an appropriate workflow, and that in the process we have not destroyed faint background details.

5 - A note about background samples

When creating a background model, some people tend to define a large number of samples with the idea that the more samples we place, the more accurate the background model will be.

The problem with this approach when removing gradients is that, if our image contains subtle variations in the background NOT caused by gradients, a background modeled after many samples will catch these variations, more so if the variations are not so subtle.

For example, look what happens in this case if we generate and apply a background model that was created from a large number of samples:

At the top-left is our original image with the sample marks (yup, that's a lot of samples!).

At the bottom-left is the background model generated. You can just tell by looking at this background model that it's not the right model to correct a gradient - unless you believe that a gradient could have that shape!

As a result, on the left is a screen stretch of the image after we've applied the background sample. Not only the background details we know this image has are pretty much gone, but also we can see some darkened areas - especially around bright stars or even the two clusters - that we can tell are processing artifacts. We've over-corrected our background.

So although there are cases where a large number of samples is justified, be careful when dealing with gradients, and always stretch your background model to make sure that it indeed shows the shape of what you'd expect from a gradient.

6 - Wrap up

As always, this tutorial takes a bit of time to read, but it really only involves four very very simple processing steps:

• We screen-stretch our image to view the gradient
• We histogram-stretch a duplicate of the image to place samples at the right places
• We create and apply the background model
• We verify that the model generated is appropriate and that our final image is properly corrected

For someone with some experience working with PixInsight, this session could be carried out in just 5 to 10 minutes.

As always, feel free to leave comments, questions, suggestions...

• The NC part means Non-Commercial, in other words,  you may not use any of my images or content for commercial purposes.
• The ND part means Non-Derivative, that is,  you may not alter, transform, or build upon any image or content posted on DeepSkyColors.com, regardless of whether I have posted such content somewhere else.

Requirements

Why not Mac? ... Short answer: because I don't have one, therefore I cannot compile and test the plug-in for the Mac.

Download it

For any version of Photoshop (except CS4 64 bits): DOWNLOAD WhiteCal

For Photoshop 64 bits ONLY: DOWNLOAD WhiteCal 64bits

By the way, WhiteCal is free (as in "free beer") and I want it to stay that way, so permission is NOT given to include this plug-in in any commercial package. If you downloaded WhiteCal, whether standalone or as a part of a package, and paid for it, please let me know. Having said that, if you find it useful and would like to make a small donation, please use the "Donate" button below. This will entitle you to receive notifications of new upgrades to this plug-in. The Donate button will take you toPayPal - don't worry when you see the donation goes to AR Networks. Yes, that's me.

Installing WhiteCal

Once extracted, copy the WhiteCal.8bf file to the Plug-Ins directory in your Photoshop installation.This usually is something like C:\Program Files\Adobe\Adobe Photoshop CS2\Plug-Ins but it may be different depending on operating system and t Photoshop version you're running.

After you've copied the file to the Plug-Ins directory, start (or restart) Photoshop.

Using WhiteCal

At that point, you can simply click OK to accept the values WhiteCal has calculated, or if you like, you can enter your own.

What happens if I don't make a selection before running WhiteCal?

Does WhiteCal work well with saturated areas?

A note about luminance

In order to preserve the exact luminance as the original image, it is recommended to follow this process:

• Duplicate the layer where you'd like to apply WhiteCal.
• Make the blending mode of that new copy to "Color".
• Apply WhiteCal over that new layer.
• Merge that new layer back with the original

The above process will adjust for color balance without affecting the luminance at all. Again, for small corrections, you could use WhiteCal directly over your working layer, although in general I do recommend following the method I just described.

Bit depth

Color Mode

WhiteCal and masks

]]> 2010-05-26T00:31:00-08:00 RBA http://blog.deepskycolors.com/archive/2010/05/25/photoshop-Plug-in-Rgbc.html http://blog.deepskycolors.com/archive/2010/05/25/photoshop-Plug-in-Rgbc.html About RGBCRGBC is a simple Photoshop plug-in that allows you to easily and very precisely modify the weights of the red, green and blue channels in an RGB image.

Requirements

Why not Mac? ... Short answer: because I don't have one, therefore I cannot compile and test the plug-in for the Mac.

Download it

For any version of Photoshop (except CS4 64 bits): DOWNLOAD RGBC

For Photoshop 64 bits ONLY: DOWNLOAD RGBC 64bits

By the way, RGBC is free (as in "free beer") and I want it to stay that way, so permission is NOT given to include this plug-in in any commercial package. If you downloaded RGBC, whether standalone or as a part of a package, and paid for it, please let me know. Having said that, if you find it useful and would like to make a small donation, please use the "Donate" button below. This will entitle you to receive notifications of new upgrades to this plug-in. The Donate button will take you toPayPal - don't worry when you see the donation goes to AR Networks. Yes, that's me.

Installing RGBC

Once extracted, copy the RGBC.8bf file to the Plug-Ins directory in your Photoshop installation.This usually is something like C:\Program Files\Adobe\Adobe Photoshop CS2\Plug-Ins but it may be different depending on the operating system and the Photoshop version you're running.

After you've copied the file to the Plug-Ins directory, start (or restart) Photoshop.

Using RGBC

From there, just enter the values you want in the R, G and B boxes, and click OK.

Does RGBC rescale my input?

A note about luminance

In order to preserve the exact luminance as the original image, it is recommended to follow this process:

• Duplicate the layer where you'd like to apply RGBC.
• Make the blending mode of that new copy to "Color".
• Apply RGBC over that new layer.
• Merge that new layer back with the original

The above process will adjust for color balance without affecting the luminance at all. Again, for small corrections, you could use RGBC directly over your working layer, although in general I do recommend following the method I just described.

Bit depth

Color Mode

RGBC and masks

]]> 2010-05-25T23:36:00-08:00 RBA http://blog.deepskycolors.com/archive/2010/05/19/2010-Dark-Sky-Times-Calendar.html http://blog.deepskycolors.com/archive/2010/05/19/2010-Dark-Sky-Times-Calendar.html
A few tips in how to read the table:

• This Table Summarizes the period of darkness between astronomical twilights with the moon below the horizon.
• Time notation follows military time without trailing zeroes (4=4minutes past midnight, 130=1:30AM, 1458=2:58PM, etc)
• All time shown for a given date are happening during the night immediately following noon time on that date (i.e. if you were to go observing/imaging after work on May 4, the moonless period of the night would start at 9:43PM on May 4 and end at 1:43AM on may 5.
• Blank cells mean the moon is above the horizon between the astronomical twilights.
• Original moon rise/set and astronomical twilight times from the USNO website.
  Underscored cells denote daylight saving time start and finish                               
  

Get a poster of this image at my Zazzle Store!

Get a poster, t-shirt, mug, mousepad... with this image!

The tutorial uses an already processed version of my IFN Wide Field 2x5 mosaic.

If you would like to see the screen-shots at a bigger resolution, simply click on the corresponding "tiny" screen-shot. A few screens-hots are actually shown in the page at the maximum resolution in which they were captured, though.

The Data

The captured data was of good quality, but not a lot of it. The master files were generated from 6 subexposures of 15 minutes each,and 3x3 minutes for each RGB channel, with a SBIG STL11k camera and a Takahashi FSQ106EDX telescope with the 0.7x reducer. The data was captured at Lake San Antonio, California over four nights - LSA is a dark site that sits right at a "gray" border in the Bortle scale, surrounded by blue and some green/yellow areas. For a light pollution map of Lake San Antonio, click here and look for its location on the bottom-right corner of the image.

The Goal

The goal in this session is trying to reveal very very faint data in regions of our image we suspect might contain such extremely faint data, as long as we decide that revealing such data makes sense from both an artistic and a documentary perspective.

1 - Preliminary work

Please ignore the still-uncorrected seams and other "defects", as this is done from an image almost in its very original form.

We can immediately see that in particular, there's a visible structure coming out off near where the two arches join - displaying a "3" shaped cloud. We therefore do have very faint structures in our image that are not appearing in our processed image.

Now, there is a risk in trying to process an image for very faint stuff after the image has been through a complete or almost complete processing cycle. The data in our processed image may not be nearly as reliable. As far as work-flow goes, this is NOT the best moment to do this. We should have noticed much earlier in the process and attack this area back then, not now. So this is an after-thought and it involves risks we would need to keep in mind. As long as we are aware of it and we perform the needed verifications in the end, my opinion is that we can proceed.

2 - Breaking the image into large and small scale structures

First, let's remember what we're looking at:

We are going to follow a multi-scale approach, so our first step is to break the image into two (maybe three if we feel it's necessary) different scale structures: large scale structures, and small scale structures.

For that we use the ATrousWaveletTransform tool (ATWT) in PixInsight. We start by generating the image with the large-scale structures. This is accomplished by only selecting the residual layer ("R") in the ATWT tool, over a 4-6 layers dyadic sequence.

Let's build now the small-scale structures image. This is easily accomplished with PixInsight's PixelMath. All we do is subtract the image with large-scale structures from the original image, so what we have left from this operation is an image defining only the structures that were removed from the large-scale image, in other words, the small-scale structures. See below a screen-shot after this PixelMath operation has been performed, and notice how the image at the bottom only contains the small details from the original image. If this image looks similar to what you usually get when you apply a high-pass filter, you're of course right.

Now.. The image defining large-scale structures looks ok, but it is still defining some structures that we probably don't want to see there. For instance, there's clearly some glow from the brighter stars, and we want to minimize that. We want to see if we can reveal the faint dust, not star glow.

So we'll repeat the ATWT process once again, this time taking as the source our image with large scale structures, and create a new image with even larger scale structures.

See below the screen-shot displaying our three images:

From now on I'll refer to each image as follows: SS for the image defining the Small Scale structures (bottom-left in the screen-shot above), LS for the image defining Large Scale structures,and MS to the image defining even larger scale structures (Mega-large structures? :-)

3 - Processing large scale structures

Now that we've broken our image into three images, each of them defining different scale structures,we start doing some processing in them. We start by stretching the histogram to the ML image. Not too much, but enough to see if there is "stuff" in our targeted area.

And yes, the area that once was mainly dark, now reveals some structures - still faint, but now visible.

This is actually the epicenter of this processing session - whatever we do here is what will contribute to the enhancements we want to add to our image. We can stop right here after this stretch,or we could try many other things... We could increase the color saturation so the structures we're"revealing" also come with an increment in color visibility... We could apply some wavelets to enhance the structures we're bringing from the "darkness", we could use curves and/or PixelMath to intensify the contrast in these structures, we could even experiment with HDRWT...

And these improvements aren't limited to the MS image only. We could also add some sharpening to the SS image for example, or also experiment with any of the processes mentioned in the last paragraph. Likewise for the LS image.

This is not to say we should go crazy. We must keep our eyes on our goals and on what the data is"telling" us. My point is only that we have a plethora of tools we can use that may (or may not) help us achieve that goal, and that's part of the fun I find in image processing - that we can experiment with these tools to see which ones help us reach the goals we aim to achieve.

In this example I decided to just stay with this somewhat subtle histogram stretch, since that's all I want at this point.

Of course, after our stretch to the ML image, everything else is also stretched, and we don't want to bring all this back to our image (we could but it's not what we have decided we wanted to do during this session), so the next step is to create a luminance-based mask that will protect everything but the darkest areas in our image.

4 - Creating the luminance-based mask

To create our mask we start by extracting the luminance from the original image.

With that done, we do a slightly aggressive histogram stretch, then use the ATWT tool to reduce the image to large structures. We don't want the mask to be based on very very large structures, so in this case, excluding only the first five layers using a dyadic sequence works well. The reason we don't want to go further to say, 6, 7 or 8 layers is because, as we will see in a minute, it's not a bad idea to include in the mask some bright "spotting" caused by large stars. If we extracted only the very large scale structures, such "spots" would be gone, since they would fall under a"smaller scale" category. Also, our mask may not be protecting well our data.

Here's our mask after the histogram stretch and isolating large (but not very large) scale structures:

In this case, such "darkest area" is clearly the one above the two IFN arches,but if we had other areas similarly dark in the image, it's ok. If that happens, we can decide whether to manually mask those other areas or leave them.If we leave them, all that would happen then is that we would be "bringing up to par"the fainter signal in those areas as well, which may be a very good thing depending on the case. If we choose to mask them out manually, that's also ok as long as we have a good reason, both from an artistic and a documentary point of view (more on that in a second).

After visually adjusting the threshold with the Binarization tool on our to-be mask, this is what we get:

• We haven't found a threshold point where only the area we're targeting is excluded.

  So we need to make a decision of whether we'll leave the mask as it is,meaning our stretch will affect those areas as well, or whether we choose to manually protect those areas (making them white, basically). By looking at the original image and at a heavily stretched view of our almost-unprocessed image we can see that those other "black islands" happen over areas that don't have any significant additional IFN data, so if we apply the additional stretch, it will not contribute to enhance very faint details,and instead, rather than "extracting" additional very faint data, we would remove from the image the fact that the IFN is less dense in those areas in contrast with their surroundings. This brings up a difficult question that I'll address in a second.

• There are some bright circles in our targeted area. That's ok and in fact not a bad thing as we shall see in a moment.

1. Do nothing, and abandon this session. If we do this, our image will not document the fact that above the arches there are differences in IFN density.

2. Leave the mask as it is. This will reveal the IFN above the arches, but our final image will remove or attenuate at least the also very important detail that in the "black island" areas there is an important change in IFN density.

3. Manually make sure the "black islands" also get mask protection.This will reveal the IFN above the arches, and preserve the fact that the areas now targeted by the "black islands" have a lower IFN density.

Based on the above three options, I determined that the third option is the one that better reflects "where there is IFN and where there isn't".I conclude then that manually masking those areas is the best decision in order to meet our goals, and that the documentary value of the image is greater by choosing that option.

Before going any further, we notice three things:

• First, we see that the ACDNR didn't do much as far as fainting the "secondary black islands".We therefore will be using the clone stamp (there's no Paintbrush in PixInsight) to manually make these areas white.

  Using the clone stamp (or a paintbrush) to "mess up with masks" is quite acceptable to some people but almost sacrilegious for others. For this second group,the message is: We are about to apply a histogram stretch with a mask. This means we have already made the decision that we want to brighten some areas in our image while not doing so in others (not only that, we're stretching only very large scale structures, so we're even more selective).And although some may think that the moment we use the clone stamp (or the paintbrush) to alter a mask we are introducing a very arbitrary processing to our image, I have tried to explain the thinking process that led to this decision. It is a 100% reproducible and non-arbitrary process that rather than ignoring what the data tells us, it contributes to a better representation of the real differences in IFN density.

  We will then proceed to "whiten" these black "spots" with the clone stamp tool.

• Second, the tiniest stars that were still"seen" in the large dark area of our mask are pretty much gone after applying the noise reduction. That is good.

• And last, we notice that there's still a blur for the areas where the brighter stars were (mainly 2-3 in this case). That is not only ok,is actually good. This is because one could expect that when we stretched our"MS" image, there might still be some residual flux from these stars in that image. By having a mask that gradually "protects" this area, we avoid to"reveal faint stuff" that is in fact, nothing but "glow" from a bright star.

With all this done, it is time to apply this mask to our original image.Areas in red are the areas that are being protected. Notice the "black islands"are gone but not so the bright spots over the few bright stars that are not protected.

• Our image with the small scale structures.
• Our image with the large but not so large scale structures.
• Our image with the very large scale structures.

As an alternative, we could use different formulas that I'll mention in a minute.

Now, instead of the SS+LS+MS formula, we could have used other formulas that would tend to maximize or minimize the effect, using our own criteria. For example, instead we could have used:

• Original+SS+LS+ML. This will minimize the processing done on this faint stuff by including the original image - remember, we're rescaling the result of this addition, so including the original image in the equation will produce a result more similar to the original image.

• SS+LS+(MS*x) where x is a number that, if less than one, will also minimize the stretch done on that image, and if larger than one, it will emphasize it even more.

• Same as above but using different ratios for each - or some - of the sub-images.

And other variations. Again, although a simple addition will probably give us a result in accordance to what we want, experimentation can be fun...

You may be wondering... If we only modified the MS image, why did we need to extract the intermediate LS image? Couldn't we just extract the SS and MS images so that they both add up nicely when they're put back together?

The answer is yes, we could have done that. The purpose of creating an intermediary large scale image is actually twofold:

• First, it gives us a chance to experiment modifications in either or both of the LS and MS images. In this tutorial we finally didn't modify the LS image, but that's because we've skipped some of the"experimental" procedures that I did when processing the image. It was after experimentation using different methods that I decided to make modifications only on the MS image and not the LS image.

• Second, even if we ended up not modifying the LS image, when we add everything back together, due to the fact we've considerably altered the luminosity of the MS image, if we were to add only the MS and SS images (assuming our LS image was the result of subtracting the original image from MS, which is not), the result would likely NOT be well balanced. By including an intermediate image, we help rebalancing the luminosity of the image. This is a similar effect to adding our scaled images along with the original.

5 - Data or artifacts?

There's a few things we can do to see whether this "dust" we now see is real or not. As a first step we're going to compare the image we started with against tour final image. To do that, we invert each of them, and then do an aggressive histogram adjustment to each image, separately, until both of them have similar intensity strength (meaning we'd have to go a bit further stretching the original image), then compare them:

We can see they look extremely similar, which means we haven't added anything to the final image that wasn't there before. We've simply made it a bit more visible, without inducing perceptible noise nor degrading the already bright structures in that area (in this case just stars) or anywhere else on the image.

However, this compares our original already-processed image with our result. We have not verified that the structures we've enhanced compare well with our data as it was when the image was still linear. To verify that, we will do the same but comparing the original linear image with the other two: the image we used before starting this session and our final image at the end of it:

As we can see, despite mainly qualitative details and some uncorrected seams and defects in the original linear image, the areas above the arches where the IFN intensity is higher seem to match nicely across all three images, in particular the 3-shaped cloud in the middle. Therefore the conclusion I reach is that this processing session yielded acceptable results and did not fabricate any non-existing signal.

6 - Wrap up

Having said that, the thing is that "all this" isn't complicated at all (I maybe made it look complicated by writing not only about what we do, but also why we do it, what other options we have, and a thinking process), but the fact is that "all this" can be wrapped up into four very simple steps:

• Break the image into small, and large scale structures
• Lightly stretch the image with the large scale structures
• Create a mask so the process only happens on the darkest areas of the image
• Add everything back together

For someone with some experience working with PixInsight, this session could be carried out in just 10 to 15 minutes.

The possibilities however go well beyond this, and depending on our goals, we could use this technique to do many very different tasks. For example, we could use wavelets over either the large or small scale images, to enhance the details at those scales. Or we could apply noise reduction over some - or all - of these images to attack noise at different scales (the ACDNR tool however is flexible enough to allow us doing that without us having to break down the image), adjust for saturation at different scales, and a very long etc.

Get a poster, t-shirt, mug, mousepad... with this image!

Intro

The image

The complete image is  my IFN Wide Field 2x5 mosaic. I originally captured the first 8 frames on April 6, 7th and 8th, 2010, and I decided to process them after a not very promising weather forecast ahead that would delay the capture of the last two frames. However, one week later, on April 16th, I was able to get out one more time and captured these two additional frames. Since I didn't want to start processing everything all over again, I processed these two frames individually before bringing them to the larger mosaic. Processing a mosaic in several steps however is not recommended!!

This tutorial describes the first part of the luminance processing for these two frames. The two master luminance files are available upon request.

NOTE: The screen-shots are wide because they were taken on a 2-monitor system, which is how I usually work, generally placing the image on my best monitor and the processing tools on the "bad" one :-) This, unfortunately, forced me to reduce the resolution of the screen-shots. However, if you would like to see the screen-shots at their full resolution, simply click on the corresponding "tiny" screen-shot (JPEG compression artifacts are however present and do impact the quality of the image).

The Data

1 - Aligning and balancing the mosaic frames

First, both frames are registered and calibrated individually, with their darks, flats (a unique set for each frame) and bias. I used DeepSkyStacker for that, but of course, any other software (PixInsight, MaximDL, CCDStack, etc) could be used as well. After that, we load both master luminance files in PixInsigth and using a STF, we crop the images to eliminate "bad" edges. After this step, I would usually adjust for background gradients using PixInsight's DBE.

After the two master luminance files are ready to be put together, we run the StarAlignment tool, setting it to "Register/Union Mosaic" and selecting the "Generate masks" option (we're going to need those masks). The "Frame adaptation" option is nice in general cases to correct for differences in background illumination and signal strength, however, I've noticed it sometimes can wipe out very faint signal in the background. Since our goal here is to reveal as much IFN as possible, we do not check that option.

After StarAlignment has done its job, we can see both frames already nicely put together. As it usually happens with astroimages, the images are very dark and we can barely see anything but stars and a faint trace of M81.

We now run the ScreenTransferFunction (STF from now on) and click the "A" icon to let PixInsight do a very aggressive automatic screen stretch, so we can see what's there. Remember that STF does not change our data, it only "stretches" it for our screen.

After this aggresive screen stretch we can already see there's "stuff" in the background. We also see that the background illumination and the signal strenght are not uniform among both frames.

2 - Histogram adjustments, then some more

In some situations I would do a DBE right at this point. Although a carefully executed DBE could improve the uniformity of our background,  I chose not to do it in this case, to avoid constructing a background model that could alter the natural but very faint illumination from the IFN. This is not a problem with DBE but rather, I'm trying to avoid a possible problem with me!

We're ready then, for a first non-linear histogram stretch. This means we'll deactivate the STF now, as, from now on, we want to see what we're really doing.

This first histogram stretch doesn't do much to bring out the faint detail we seek. Also notice that when I do histogram adjustments that I consider critical, I resize the histogram dialog a lot, covering my entire left monitor! This by the way, is not a requirement, just something very nice to have :-)

If you look closely, in this stretch, PixInsight is telling me I'm "dark clipping" 20 pixels (a 0.0001% of the pixels in the image). If you click on the screenshot, the top number under the histogram graph in the middle is giving us that information.We definitely do not want to clip the histogram, especially at this early stage, but something like 0.0001% is acceptable. 20 pixels, that's ok.

This time we're clipping the black point a 0.1177% according to PixInsight. That's still very ok. It's still a very insignificant amount and it helps us get some contrast. Also notice that to perform this stretch, I zoomed in the X axis of the histogram by a factor of 9. This helps a lot in finding the point where the histogram curve starts to rise. Likewise we could zoom in the Y axis if we liked. The histogram tool in PixInsight is, no doubt, the way a histogram tool should be for processing astro-images.

The truth is, I will perform as many histogram adjustment iterations as I feel I need, as long as the resulting image looks better to me, I'm not clipping it, and I'm not going overboard either. When I see that I cannot improve the image to my satisfaction anymore (again, without clipping it), then I stop.

As you can see, after these histogram stretches, M81 is starting to look a bit saturated. It's not completely blown up, but it's getting there.... Here's the deal... I know that in the 8 mosaic frames I've already processed, M81 is already there (barely, but it's there), nicely processed an all, so when it's time to overlap these two frames with the already processed mosaic, I'll just place  this layer under the already processed image. In other words, I'm not concerned about M81 in this image, which gives me more freedom to work my way to make the IFN pop nicely.

Having said that, the short answer for dealing with this is of course using a "gradual luminance-based mask with variable mid tones and white point". Ok, that was a mouthful, but in practice is very simple. The trick is, we don't want the mask to fully protect the galaxy, this being done in two different but related fronts:

• By building the mask based on the luminance, the mask would be gradual, that is, it will be brighter in the brighter areas of the galaxy (protecting them better from saturating), and fainter in the outer arms.

• In addition to that, we do NOT want the mask to fully protect our image. That is, we want our stretches to actually affect the galaxy, just not nearly as much as everything else. To do that we "dim" the mask by lowering its white point. This process of adjusting the white point of the galaxy should be iterative for every new histogram stretch we perform - that is, after we've done our stretch, with the mask in place, we adjust the histogram of the mask until we see the galaxy (or whatever other object we're protecting) blend well with its surroundings. Of course we work this with a real-time preview.

3 - This is getting noisy

If you click on the screen-shot you'll see the image really is getting noisy. Unfortunately, the JPEG compression even for the "real sized" screen-shot, and the fact that even the large screen-shot shows the image at a reduced size, doesn't give a good picture of what we're dealing with, but let's just say that yes, the image is getting noisy because not only we just stacked 6 subexposures during stacking/calibration, but the IFN sits barely above the noise.

So in any case it's clear that we need to solve this two problems, and quickly. It makes sense to "correct" for the noise first, as the operations to correct the stars will work better on an image with a better SNR.

To deal with the noise, my favorite tool is the ACDNR tool from PixInsight. ACDNR is a very CPU intensive operation, so while we tweak the parameters, it's better to experiment with a preview, as shown in the screen-shot below. We try to select an area in our preview that has some variety: very low SNR areas, low SNR areas and if possible, also some high SNR areas. We don't really have any area high in SNR here, so an area with very low and low SNR areas works ok.

A good understanding of all the parameters in ACDNR is important, so if you're not familiar with this tool, refer to the ACDNR section in my Unofficial PixInsight Guide.

In this case, we definitely check the "luminance mask" option. We also used the default edge protection values. I'm not sure why I didn't take advantage of the prefiltering process, as it does an excellent job with very noisy images (maybe I did, but my notes don't mention it and I'm just reading from the screen-shot). I would definitely suggest to preview the effects of using the prefiltering process in ACDNR. Regardless...I chosed the morphological median "robustness" as it works better to preserve sharp edges.

As for the amount and iterations parameters, I always favor small amounts but several iterations (it usually works better and more gradually). Last, I used a high value for the standard deviation because the main purpose of reducing the noise at this point - although we know there's going to be little background "free" in our image - is to attack what otherwise would be considered "background noise", and high StdDev values usually work best for that.

3 - Star "management"

Applying a MT to an image to correct the stars unquestionably requires a star mask that protects everything but the stars. Without a star mask, the MT would be applied to everything in the image. Not only the results will not be satisfactory, a true MT takes a well-defined structuring element as a model for the transformation. In this case the structuring element is a circle (stars are, well, round), and so it makes sense to apply the transformation only to circled structures. A star mask that  protects everything but the stars does that.

So we start by creating a good star mask...

A star mask can be easily created with PixInsight's StarMask module, although for this occassion I chose to create it "manually" using the ATrousWaveletsTransform (ATWT) tool. This is easy - just eliminate from a duplicate of the luminance all layers except for the "R" (residual) layer, on a 4 layers dyalic sequence, and we're done.

I often like to binarize the star mask and then blur it a bit  - MT will work well with such strong masks. In this case however I chose to simply adjust the white/mid points of the histogram to make the mask stronger - which also works well. Here's how the star mask looks like:

Here's the image after the morphological transformation. Notice how the very tiny stars are no longer disturbing the scene, and the longer ones are not "in your face" anymore. This also helped clean up the image from the "in your face" panorama of an overwhelming field of stars.

Final words

As I just mentioned, our luminance is clearly not finished. We need to reduce the flux and halos in the brighter stars if we like (I often do). And then comes the color, which, after processed independently, will make us do some adjustments to the image after combining it with the luminance. And on top of that, in this particular case we'll then need to make sure everything will match nicely with our already processed 2x4 mosaic (one big reason why mosaics should be processed all at once, and not in pieces, if at all possible).

The good part is, we've achieved our goal of making the IFN pop nicely, without an overwhelming amount of noise (although the compressed JPEG artifacts may give the wrong impression) or the stars "eating" up the view, and further processing on this image shouldn't be as demanding and more similar to processing a "regular" astro-image.

We haven't used the curves tool, DDP, wavelets (other than to build a star mask), HDR tools, etc. In a nutshell, all we've really done is:

• Three histogram stretch iterations
• One pass at reducing the noise
• Another histogram stretch
• One morphological transformation to reduce star size and impact
• One last histogram stretch

In the next tutorial, also using this image of the IFN as example - just not these two frames - I will describe a way to make pop some of the very faintest stuff on this particular image that are sitting in an area that after all the techniques described in this tutorial and more, was still presenting a very dark sky background - using some simple multi-scale techniques.

HLVG is a chromatic noise reduction tool that attempts to remove green noise and the green casts such noise may cause in some images. It is based on PixInsight's SCNR Average Neutral algorithm.

The idea is not new. We all know that with a very few exceptions (some planetary nebulae, comets, etc), there are no green objects in the sky. Therefore, if we've already correctly calibrated and color-balanced an image and it's free of gradients (to the best of our ability at least), we have to assume that if something else looks green in our images it's got to be noise...Don't mistake gradients with noise. Removing gradients are best dealt by subtracting a good background model. Chromatic noise on the other hand is tricky, since it "overwrites" the real data we want.

There are several techniques widely used to deal with this problem, however most of them rely on selections and adjustments that sometimes are not easy to execute. SCNR (the base algorithm used by this plug-in) is in my opinion one of the most reliable methods to deal with "green noise" and it works the same every time, without having to worry about anything, just click OK and you're done.

Some examples

The following three examples are somewhat "extreme", and in fact a couple of them do include uncorrected gradients, that HLVG obviously does NOT correct (see section above), but hopefully they serve the purpose of showing the effect of applying HLVG over a "green polluted" image.

Before HLVG	After HLVG
Before	After
Before	After

Requirements

Why not Mac? ... Short answer: because I don't have one, therefore I cannot compile and test the plug-in for the Mac.

Download it

For any version of Photoshop (except CS4 64 bits): DOWNLOAD HLVG

For Photoshop CS4 64 bits ONLY: DOWNLOAD HLVG 64bits

By the way, HLVG is free (as in "free beer") and I want it to stay that way, so permission is NOT given to include this plug-in in any commercial package. If you downloaded HLVG, whether standalone or as a part of a package, and paid for it, please let me know. Having said that, if you find HLVG useful and would like to make a small donation, please use the "Donate" button below. The Donate button will take you toPayPal - don't worry when you see the donation goes to AR Networks. Yes, that's me.

Installing HLVG

Once extracted, copy the HLVG.8bf file to the Plug-Ins directory in your Photoshop installation.This usually is something like C:\Program Files\Adobe\Adobe Photoshop CS2\Plug-Ins but it may be different depending on the operating system and the Photoshop version you're running.

After you've copied the file to the Plug-Ins directory, start (or restart) Photoshop.

Using HLVG

From there, just select Strong, Medium or Weak, depending on whether you want HLV go really hard on getting rid of treen noise, t moderately or simply slightly. The recommended setting i>Strong.

A note about luminance

In order to preserve the exact luminance as the original image, it is recommended to follow this process:

• Duplicate the layer where you'd like to apply HLVG.
• Make the blending mode of that new copy to "Color".
• Apply HLVG over that new layer.
• Merge that new layer back with the original

The above process will get rid of unwanted green noise and hues without affecting the luminance at all. HLVG doesn't degrade the luminance considerably, so using it directly doesn't do a bad job, although I do recommend following the method I just described.

Bit depth

Color Mode

HLVG and masks