HAPI stands for Heliophysics Data Application Programmer’s Interface. It is a modern API that makes it very simple to deliver time series data to applications. You can interact with HAPI directly from the browser or within a programming language.
You could use the HAPI Interface to browse the image datasets available from Helioviewer. (You could also do this on Helioviewer.org since all image datasets are retrievable with HAPI.)
Below are examples of using HAPI with Python and JavaScript. You can find a list of officially supported clients here.
If your desired language isn’t supported, you can review the API specification to write a new client.
>>> from hapiclient import hapi
>>> data, meta = hapi(
... "https://api.helioviewer.org/hapi/helioviewer/hapi",
... "AIA_304",
... "url",
... "2023-01-01T00:00:00Z",
... "2023-01-01T23:59:59Z"
... )
>>> print(data)
[(b'2023-01-01T00:00:05Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__00_00_05_129__SDO_AIA_AIA_304.jp2')
(b'2023-01-01T00:00:41Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__00_00_41_131__SDO_AIA_AIA_304.jp2')
(b'2023-01-01T00:01:17Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__00_01_17_130__SDO_AIA_AIA_304.jp2')
...
(b'2023-01-01T23:58:17Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__23_58_17_132__SDO_AIA_AIA_304.jp2')
(b'2023-01-01T23:58:53Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__23_58_53_131__SDO_AIA_AIA_304.jp2')
(b'2023-01-01T23:59:29Z', 'https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__23_59_29_140__SDO_AIA_AIA_304.jp2')]
// Include hapi-0.0.1.js from https://github.com/hapi-server/client-javascript
// <script src="hapi-0.0.1.js"></script>
hapi("https://api.helioviewer.org/hapi/helioviewer/hapi",
"AIA_304",
"url",
"2023-01-01T00:00:00Z",
"2023-01-01T23:59:59Z",
(data, meta) => {
console.log(data);
}
);
/**
* {
* Time: ["2023-01-01T00:00:05Z", "2023-01-01T00:00:41Z"...]
* url: ["https://helioviewer.org/jp2/AIA/2023/01/01/304/2023_01_01__00_00_05_129__SDO_AIA_AIA_304.jp2"...]
* }
*/
This feature is enabled by SAMP, a standard by the International Virtual Observatory Alliance. SAMP is a protocol that allows different applications to send messages to each other. When JHelioviewer is running, it acts as a SAMP Hub and accepts requests to load images specified in the SAMP message.
Helioviewer can communicate with JHelioviewer thanks to sampjs, a JavaScript library which implements the SAMP protocol, and a library we developed called jhvrequest which provides a JavaScript interface for sending datasets to JHelioviewer.
Technically speaking, the mp4 itself is not sent to JHelioviewer. Instead, the list of the layers in the movie and the movie’s timespan are sent to Jhelioviewer so that it can reconstruct the movie.
Currently movies containing XRT layers are not supported.
To open a movie in JHelioviewer, first have JHelioviewer running, then open one of your movies in helioviewer.org.
In the bottom right of the movie player window you will see an “Open in JHelioviewer” button.
If JHelioviewer is not running, the button will say “JHV is not open”, and the button will not be clickable. Make sure to open JHelioviewer first.
When you click the button, JHelioviewer will display a notification asking if you’d like to accept the incoming request.
Click Yes to load the movie in JHelioviewer.
]]>We have been working on this for some time and we’re happy to announce that coordinates are back on Helioviewer. Users can show the mouse position in helioprojective Cartesian or radial coordinates. The mouse position provided by Helioviewer.org approximates the true position. While we do believe the coordinates returned to be reasonably accurate, there may be cases where the displayed mouse coordinate is incorrect. Users are encouraged to use other tools for work that requires more accuracy.
We tested the veracity of the Helioviewer.org mouse position using sunpy, a free and open-source Python package for solar physics data analysis that has a sophisticated and well-tested coordinate framework.
The image below shows the mouse pointer hovering over a sunspot. Helioviewer.org shows the coordinate position as (-593, -264) arcseconds.
If we take the Helioviewer.org coordinate position, and use sunpy to plot that position on the same data (red dot), we get the following image:
The red dot in the sunpy image is in approximately the same position as the location of the mouse in the Helioviewer.org image above.
]]>They can be found by clicking on Data Sources > Features and Events > CCMC.
The CCMC is a multi-agency partnership enabling, supporting, and performing research and development for next-generation space science and space weather models. The CCMC collects flare predictions based on a number of different algorithms and makes them available via an API and their own browsing tools.
Each flare prediction shows the probability of GOES C, M and X flares in the local area of the pin.
Clicking on the pin itself pops up a window with a little more detail
Clicking on “View source data” brings up a larger window that shows the complete data associated with that particular flare prediction
You can also overlay features and events from the HEK. Here is an example showing HEK Eruption, AMOS V1 REGIONS, and ASAP 1 REGIONS results overlaid on an AIA image
A small note about the display of flare prediction results. Since flares occur in active regions, the flare prediction pins wll often overlay each other and other HEK information for active regions. Mousing over the result type you want will highlight the particular HEK or Flare Prediction pins shown.
For example, in this example, the mouse is over HEK > Eruption > EruptionPatrol and only those results are shown:
Similarly, we can show the ASAP 1 REGIONS results only by mousing-over CCMC > Flare predictions > ASAP 1 REGIONS .
If you have any questions or comments regarding flare predictions, please send us an email or file an issue on the Helioviewer.org project page.
]]>Comments? Questions? Bugs? Send us an email or post an issue on GitHub
]]>Solar Orbiter was launched on February 9th, 2020. It is designed to take in-situ measurements of the inner heliosphere and nascent solar wind, and perform observations of the Sun’s polar regions. Solar Orbiter orbits the Sun (not the Earth) and its orbital inclination and distance from the Sun will change substantially during the mission lifetime to get ever better views of the Sun’s polar regions. Most observations will be from off the Sun-Earth line (note that most STEREO observations have been taken from well away from the Sun-Earth line). Additionally, given the mission profile, data download rates and latencies can vary, and so images close to real time are nominally not available.
EUI observes the Sun in extreme ultraviolet light, and consists of two High Resolution Imagers (HRIs) and one Full Sun Imager (FSI). The HRIs take high resolution images of portions of the solar atmosphere - they do not view the entire disk of the Sun. The FSI views the full disk of the Sun, and also images a wider field of view compared to AIA, and so can image the extended solar corona.
Data from EUI are processed into images for use with helioviewer.org and JHelioviewer by the Helioviewer Project partner institute the Royal Observatory of Belgium. We hope you enjoy examining EUI images.
]]>Update 2022-05-02 21:20
The helioviewer migration to the new server is nearly complete. The Helioviewer Website is up and running.
We are still working on setting up the data pipeline for SOHO and STEREO so these image sources will not be updated for some time. Another update will follow when these image sources are updated. This impacts both GSFC and GSFC Beta
We are still working on bringing up the JPIP server, which should be up shortly. In the meantime GSFC Beta is still available.
]]>We will be migrating helioviewer to a new server with more available storage space. This will resolve the problems we have been having lately with images not loading, and image sources lagging behind what should be available.
Another announcement will be made on May 2nd when the migration is complete.
]]>Daniel here, as one of the newer members to the Helioviewer Project, I’ve put together this guide for setting up a development environment and using git to make pull requests to help with onboarding any future contributors we may have.
This page is here to describe the process for setting up a local development environment that can be used for testing changes for https://helioviewer.org. This document also goes over setting up a branch on GitHub for making pull requests, which you may skip if you’re already familiar with git and the pull request process. If you have any questions about the steps here, please let us know by emailing contact@helioviewer.org so we can update these steps.
In Summary, this page will go over:
If you’re already familiar with GitHub and git, then you’ll most likely just be interested in section 3 on setting up the local environment. All other sections go over how to use GitHub to fork our repositories, clone the project, and make a pull request. If you know how to do these things already then you can ignore these sections. If you’re new to GitHub and git, I recommend going through all sections.
If you haven’t worked on Helioviewer yet, you’ll want to start here. In this section, you’ll make your own copies of the helioviewer.org repositories on GitHub that you can use to make pull requests later on. You’ll need to create a GitHub account which is not covered here.
Once you have an account, log in and go to the API Page and click fork in the top right corner (See images below). After forking the API, create a fork for the helioviewer.org repository as well.
After forking, you should see the api and helioviewer.org on your GitHub account in your repositories list. Like this:
Next, you need to clone your forks to your computer so you can make changes and test them there. I’ll do this with Github Desktop since it’s very user-friendly, but if you’re already familiar with Git, feel free to use whatever tools you’re comfortable with.
Repeat the steps to clone helioviewer.org as well.
Great, now you have your own copy of helioviewer on Github, and on your computer! Now you’re ready to run the application yourself. To do this, you will need Docker (or podman if you’d rather not use docker). The instructions that follow are for Docker.
A container has already been set up to manage a lot of things for you. The Helioviewer development container will automatically download images, delete any images older than 1 day (to conserve space), and configure your local copy of helioviewer for running on localhost.
To run the container, you’ll need the paths to your API and Helioviewer.org repositories that you saved in step #2.
Select the command below based on your environment (windows cmd, windows powershell, mac, or linux). Execute the appropriate command in your desired terminal.
For Windows Users (cmd.exe):
cd C:\Path\To\Github
docker run ^
-p 127.0.0.1:8080:80 ^
-p 127.0.0.1:8081:81 ^
-v "%cd%/api":"/var/www/api.helioviewer.org" ^
-v "%cd%/helioviewer.org":"/var/www/helioviewer.org" ^
-d -t dgarciabriseno/helioviewer.org-docker:v1.4_setup_done
Also windows if using powershell (PowerShell.exe):
cd C:/Path/To/Github
docker run `
-p 127.0.0.1:8080:80 `
-p 127.0.0.1:8081:81 `
-v ${PWD}/api:"/var/www/api.helioviewer.org" `
-v ${PWD}/helioviewer.org:"/var/www/helioviewer.org" `
-d -t dgarciabriseno/helioviewer.org-docker:v1.4_setup_done
For Mac/Linux users:
docker run \
-p 127.0.0.1:8080:80 \
-p 127.0.0.1:8081:81 \
-v "/Path/To/API":"/var/www/api.helioviewer.org" \
-v "/Path/To/helioviewer.org":"/var/www/helioviewer.org" \
-d -t dgarciabriseno/helioviewer.org-docker:v1.4_setup_done
For details on the above command, see the Docker run reference
Now verify the container is working as expected. In docker desktop go to the Containers / Apps tab (see image below). You will see that it created a container. Next click the open in browser button to see Helioviewer running on your computer, complete with images of the sun! By default the container’s pre-installed images are in December 2021, don’t worry, in a few minutes you’ll be able to jump to today’s date and see the latest AIA images of the sun.
If the UI doesn’t work, or you just get a blank white screen, or you see the helioviewer UI, but no sun, please open an issue on the container’s github page for assistance.
Now that you have a local copy and development environment for Helioviewer. You’re ready to start modifying the source code. A typical workflow for Helioviewer looks like this:
Beta contains the latest development changes, so all new changes should be branched from the latest commit on beta.
Next you can make changes and test them in your container. When testing javascript or CSS changes, use the URL: https://127.0.0.1:8080?debug=True
The ?debug=True
will tell Helioviewer to use non-minified
CSS/JavaScript.
After making changes you can commit them with GitHub desktop. The left sidebar will show files you have changed. Please uncheck changes to Config.js. The container modifies this file for running on localhost and should not be committed. Generally you should commit often with descriptions of what you did in each commit so it’s easy to rollback a change if necessary.
Once a change is ready to submit to helioviewer, you can make a pull request after you publish your changes to GitHub. Use the “Publish branch” button in GitHub desktop to push your changes to your GitHub fork. You can do this as often as necessary. When you’re ready to submit a change to helioviewer, you’ll need to make a pull request.
Sometimes GitHub will have a message on top for “Compare & pull request” If this doesn’t show, you can make a pull request like this:
When making a pull request, set the target branch to beta. Then update your commit message to mention the change you’re making.
Lastly click “Create a Pull Request” and we’ll review your change.
]]>Helioviewer services are experiencing an outage at this time. It appears services went out at approximately 2:00 AM UTC Time on March 23.
We are working to bring it back online and will update this post when service returns.
]]>