JSol’Ex

This is an experimental feature available since JSol’Ex 3.1.0. It enables the correction of jagged edges which can appear on images. These jagged edges are common on images captured with a spectroheliograph and come from different causes:

Jagged edges correction can reduce these defects dramatically. It only requires a single parameter: a "sigma" value which lets you adjust the number of points taken into account in the correction model. A value of sigma close to 0 will be very restrictive and will only correct small defects, while a higher sigma value will correct larger defects, at the risk of distorting prominences, for example.

Once images are generated, they appear one after each other in tabs. These tabs provide you with the ability to tweak the contrast of images and save them, typically when you unchecked the automatic save option.

It is possible to zoom into the images by using the mouse wheel. In addition, right-clicking the image will let you open it into your file explorer or in a separate window.

The "ImageMath" mode is a mode which will let you declare which images to generate by writing small scripts. It relies on a simple script language designed specifically for generating Sol’Ex images.

Let’s illustrate this by going back to our previous example, where you wanted to generate images in the [-10;10] pixel shift range. In the "simple" mode, you had to manually enter all pixel shifts, which can be a little cumbersome. In the "ImageMath" mode, we have a language which will let us to this with a single instruction.

First, select the ImageMath mode in the select box and click on "Open ImageMath". The following interface show up:

On the left side, "Scripts to execute", you will find the list of all scripts which will be applied in your session.

Scripts must be saved on your local disk and can be shared with other users. Their contents is editable in the rightmost part of the interface.

Start with removing the contents of the sample script and replace it with:

Then click on "Save". Select a destination file and proceed: the script is now added to the list on the left, as being executed in this session.

Click on "Ok" to close ImageMath and only keep the "geometry corrected (stretched)" images. Click on "Ok" to start processing, you will now have the 21 required images generated:

For now we’ve only used one function called range, which let us generate about 20 images, but there are many others available.

Please refer to this page for the complete list of functions available in ImageMath.

In the previous section, we have seen the building blocks of ImageMath, which permit computation of new images. Scripts go beyond this by combining these into a powerful tool to generate images. As an illustration, let’s look at this script which will let us generate an Helium image. Helium image processing is complicated, because the Helium ray is very dim and the software cannot find it in the image. Therefore, we can use a technique which consists of taking a larger capture window which includes a dark ray, then by determining by how many pixels the helium ray is shifted from that line, we can reconstruct an image. Even so, the work is not finished, since it’s an extremely low contrast ray, so we have to substract the continuum value. Producing such images is quite cumbersome but can be simplified to the extreme with ImageMath:

Our script consists of 3 different sections: [params], [tmp] and [outputs]. The only mandatory section is the [outputs] one: it defines which images we want to have in the end. The name of all other sections is arbitrary, you can create as many sections as you want.

Here, we defined a [params] section which highlights which parameters we want users to be able to tweak for their needs. This is where we find the value of our helium ray pixel shift (HeliumShift=find_line(Line)) which is computed from the Line=5875.62 variable declaration.

Variables can be used in other variables or function calls.

Our 2d section, [tmp], defines intermediate images we want to work with, but for which we don’t care about seeing the result:

Last but not least, the [outputs] section declares the images we want to generate:

This table summarizes the special variables which are exposed to ImageMath scripts:

In addition to the functions provided by JSol’Ex, it is possible to define your own functions, which combine existing functions. For example, let’s say that you would like to draw the globe, technical details and solar parameters on more than one image. You script may look like this:

Instead of repeating the same function calls on several images, we can declare a function which would do this for us:

Functions must be declared at the beginning of the script. They can take any number of arguments, but they must always return a value in the result variable. If you declare a function, you must have a section which separates the functions declarations from your main script (for the [outputs] section).

A function can consist of intermediate expressions and can call other functions. For example, let’s create a function which will display our image with a title:

It is possible to include other scripts in your script. This can be useful if you have a set of functions which you want to reuse in several scripts. For example, we could extract the function definitions from the previous example and put them in a separate file, functions.math:

Then it can be included in another script:

ImageMath is an expression language. It doesn’t support control structures like loops or conditionals, which can sometimes be limiting. In addition, sometimes you may want to perform operations which are not available in the language itself.

To support these advanced use cases, a special function named remote_scriptgen is available. This function will call a service which will be responsible for generating a script which will contribute new variables to the current context.

The function accepts a single argument, which is a URL to the service. JSol’Ex will then create a POST request to this URL, with a JSON payload which contains the current context, that is to say the list of variables with their values at the time of the call, but also context like the processing parameters or the detected wavelength.

The JSON payload consists of 2 top level keys:

The variables can be simple values, like numbers or strings, but also arrays or objects like images:

In case of an image, the object will have a key of type with value image. The file will be available as a FITS file only.

The service must return a JSON object which contains a script key, with the script to execute in JSol’Ex. It can also return an object with an error key, which will be displayed to the user.

The scripts which are returned from the server are interpreted in a separate context, but they share the variables and user functions from the including script. The separation means that the script which is returned can itself be organized in sections, but only the outputs section will contribute new variables to the context.

For example, if a server returns the following script:

Then only the final variable will be visible to the including script after execution.

Once a batch has been processed, it is possible to review the generated images. This will make it possible, for example, to keep only images with a cloudless disk, or images without distortions.

In order to do so, in the processing options, in the "misc" tab, check the "Review images after batch processing" box:

Once processing is done, a new window will open, allowing you to review the processed images:

On the top right, you can choose to reject an image, keep it, or set it as the best image. The best image is then displayed on the left, and the current image on the right. You can then compare each image to the best image, and decide whether to keep it or not.

On the left, you have the list of images generated for each SER file. On the bottom right, you can move to the next or previous image, and finish the process.

Once you’re done, the following window will open:

This lets you choose what you want to do with the rejected images: keep them, delete them, or move them to a sub-folder (by default, they will be moved). Similarly, you can choose what you want to do with the SER files which were used to generate these rejected images: keep them, delete them, or move them to a subfolder.

If you use a script in batch mode, the part of the script will only be executed for the images you have kept, which will allow, for example, stacking only the selected images.

Note that in the stack and stack_ref functions, you will then have the possibility to specify the reference selection method manual, which will then choose the best image you have selected.

When you are in batch mode, an additional section is available in ImageMath scripts. This section allows making computations on the results of the processing of each individual image, in order to compose a final image for example (e.g stacking), or to create an animation of several images.

This section must appear at the end of a script and is introduced by the [[batch]] delimiter:

It is important to understand that only the images which appear in the [outputs] section of the individual file processing are available for use in the [[batch]] section. Therefore, the cropped image of a single SER file becomes a list of images in the [[batch]] section. Some functions, like img are not available in the batch mode. If you need individual images to be available in the batch processing section, then you must assign them to a variable in the [outputs] section:

An additional way to benefit from scripting is to reuse the results of previous sessions (typically, images produced in one or many previous sessions) without having to process a new video.

To do so, you must open the "Tools" menu and select "ImageMath editor". The interface which pops up is exactly the same as when you are processing a single video, or a batch of files. The main difference is how images are loaded. In this mode, you must use either the load or the load_many function to load images, instead of the img function.

If you process an H-alpha image, JSol’Ex can automatically search within the image for regions where the redshift (red or blue shift) is particularly strong.

To do this, you must either select the "complete" mode during processing or check the "Redshift Measurements" box in the custom image selection.

The measurements will be valid only if the specified pixel size is correct and you are using a Sol’Ex (other spectroheliographs have different focal lengths).

During processing, an additional image will be generated with the regions outlined in red and the associated speed.

Additionally, if you select the debug images, the parts of the spectrum that allowed finding these regions will be displayed.

Finally, once the detection is complete, you can generate 2 new types of renderings by going to the "Redshift" tab:

The size corresponds to the minimum size of the region to capture, in pixels. A small region will be centered around the detected filament, but it may be quite pixelated in some cases. The margin allows you to choose how many pixels to offset from what JSol’Ex detected. For example, JSol’Ex might find a maximum shift of 20 pixels, but you may wish to add 2 or 4 pixels of margin for an animation to clearly see the filament appear.

Finally, select the type of rendering:

JSol’Ex provides a tool which will let you see what the detected spectral line is for a particular video. This tool chan be used, for example, to efficiently determine the pixel shift to apply when processing an Helium video.

To do this, open the "Video analyzer" in the "Tools" section. Select a video, the tool will compute the average image then show this window:

In the upper side you can see the reconstructed average image. The red line is the detected spectral ray, which is built by figuring out the darkest points of the lines. Below the violet line, you can see a geometry corrected version of the average image. If the line was properly detected, then the corrected image should show you perfectly horizontal lines.

In the lower part of the interface, you can adjust several parameters:

We assume that we have a single SER file which window includes both the helium ray and another ray (e.g sodium) which is dark enough to be detected by JSol’Ex.

We can then proceed by steps:

We can now perform measurements: when you are moving the mouse over the image, coordinates are displayed:

The first 2 numbers are the (x,y) coordinates of the point below the cursor. The 3rd one is the one we’re interested in: it’s the pixel shift between the cursor position and the detected spectral line (in red). The 4th number will let us increase our accuracy by computing an average value from samples.

To add a sample, find a point on the helium line then click on it while holding the CTRL key. You can add as many sample points as you wish.

The 4th number is the average of distances and should be a good value to use in your ImageMath scripts. In this example we deduce that the pixel shift is -134.

Finally, JSol’Ex offers an experimental feature: you can click the "Identify" button to open a file selection window.

Then choose an image of the spectrum, as captured by your software. JSol’Ex will then try to find out which part of the spectrum it is in:

If the identification works, your image will be displayed in transparency, overlaid on the spectrum, on the left side of the image, allowing you to easily verify if the identification was successful.

You can hide the transparent image by clicking the "Hide" button.