Blog - Posts by Stuart Mumford

Artemis II Solar Eclipse

2026-04-09T00:00:00+00:00

The Artemis II mission launched on the 1st April 2026; this launch date allowed the crew to observe a solar eclipse on the 6th April(EDT) / 7th April (UTC) after transiting the far side of the moon.

Image credit NASA

We on the SunPy blog rarely miss the opportunity to talk about a solar eclipse. So when we saw the stunning photos taken by the astronauts on Artemis II, we wanted to use SunPy to compare them to other photos of the solar corona. I do highly recommend watching the recording of the eclipse on YouTube; the reactions and descriptions of the astronauts are worth it.

Amongst the many amazing photos downlinked during the mission was this image of the solar eclipse:

Image credit NASA

This image is particularly good for comparing to other solar data because the limb of the moon is clearly visible, and there are stars and planets in the image we can use as references. These features will allow us to determine exactly where and at what angle the camera was pointing. At the end of the post you will be able to see how we can overlay on this photo images taken by solar observing satellites.

Fitting Coordinate Information

To be able to compare this image with other observations of the Sun, we need to identify where the camera was pointed and how it was rotated. To do this we perform the following steps:

Extract the time information from the metadata stored in the image.
Use the time information to lookup the exact position of Artemis II.
Fit the edge of the moon to identify the location of the center of the moon, and the size of the moon in the image.
Use the three planets visible in the lower right of the image to identify the rotation angle.
Use the planets to fit the distortion of the lens.

All the code for this example is in The sunpy Gallery.

Finding the position of Artemis II

The first step is to know the time the image is taken; we can extract this from the EXIF metadata. Once we have this we query JPL Horizons for the position of Artemis II.

from sunpy.coordinates import get_horizons_coord

artemis2_naif_id = "-1024"
artemis2_coord = get_horizons_coord(artemis2_naif_id , "2026-04-07 01:06:19")

We can also use the positions returned by JPL Horizons and the coordinates packages in sunpy and astropy to visualize what part of the Artemis II trajectory was in eclipse. To see the details of how this was done see this example in the SunPy gallery.

Visualization of the Artemis II trajectory with the eclipse highlighted.

Moon Limb Fitting

The next step is to find a known location in the image, a reference point. The easiest one for us to use is the center of the moon, which we find by doing edge detection and Hough filtering, using scikit-image.

import numpy as np

from skimage.feature import canny, peak_local_max
from skimage.transform import hough_circle, hough_circle_peaks

edges = canny(eclipse_image, sigma=2)

h, w = eclipse_image.shape
radii = np.arange(0.25*h, 0.4*h, 10)

hough_res = hough_circle(edges, radii)
accums, cx, cy, rad = hough_circle_peaks(hough_res, radii, total_num_peaks=1)

A cropped view of the Moon, showing the results of the canny edge detection algorithm and the Hough filter.

Calculating Image Scale

Based on the determined center of the moon is and its radius in the image we can construct a coordinate system for the image.

from astropy.coordinates import SkyCoord
import astropy.units as u

moon = SkyCoord(coords["moon"], observer=coords["artemis_ii"])
R_moon = 0.2725076 *  u.R_earth  # IAU mean radius
dist_moon = SkyCoord(coords["artemis_ii"]).separation_3d(moon)

moon_angular_width = np.arcsin(R_moon / dist_moon).to(u.arcsec)
im_radius = rad * u.pix
plate_scale = moon_angular_width / im_radius

Using this information we can build a sunpy map (see the gallery example for details). Plotting this alongside the locations of the planets results in:

Initial coordinate system fit to image, notice that the locations of the highlighted planets are incorrect.

Fitting Roll Angle

It’s clear from the previous image that the image is rotated around the center of the moon. We can solve for this rotation by using a peak finding algorithm to locate the planets in the image and comparing these positions to the planets coordinates extracted from JPL Horizons. Doing this results in a \(-21.2^\circ\) roll angle which we can add to our Maps metadata.

Image showing the expected positions of the planets and the detected (peaks) positions of the planets, from which the roll angle is calculated.

Fitting Lens Distortion

The final correction to apply to our fitted coordinate system is the distortion of the camera lens (a Nikkor AF 135mm f/2D DC). This makes objects distant from the centre of the image appear even more distant than they should. We can quantify exactly how much the image has been distorted through comparing the expected vs actual positions of Mars and Mercury (not Saturn as it is too close to the center of the image). We add this distortion to our coordinate system and our planets now appear in the correct place.

Coordinate system fit to with additional correction for lens distortion.

Overplotting Coronagraph Images

Now that we have fit a coordinate system to the eclipse photo we can compare this observation of the corona to other data. To do this we are going to use the coronagraph on the Solar and Heliospheric Observatory (SOHO) which is located around the Sun-Earth L1 point. We reproject (or re-grid) these images to the fitted coordinate system of the Artemis II image to compensate for differences in satellite location and point of view, and then crop them to the limb of the moon.

The Artemis II solar eclipse photo with the positions of Mercury, Mars and Saturn highlighted, and coronagraph images from SOHO’s LASCO instrument plotted over the disc of the moon.

We hope you have found this post interesting. The full code for this post can be found in The sunpy Gallery. Remember, that if you are lucky enough to observe the total solar eclipse which will be visible from parts of Europe in August 2026 and you take a photo, you can try this type of analysis with your own photos, by following our previous blog post!

Process Your Solar Eclipse Photos with SunPy!

2024-04-03T00:00:00+00:00

This blog post was written in a Jupyter notebook. Click here for an interactive version:

On April 8th, 2024, a total solar eclipse will pass over North America. A total solar eclipse happens when the Moon passes between the Sun and Earth, completely blocking the face of the Sun. Only during totality, when the bright disk is completely obscured, is it possible to see with the naked eye the solar corona, the outermost layer of the Sun’s atmosphere. The total solar eclipse will give millions across North America the chance to see and photograph the solar corona.

In this blog post, we will show how you can use SunPy to process your photos of the eclipse. To do this, we will use an image from the 2017 solar eclipse that also passed over North America, the so-called “Great American Eclipse”. We will walk through processing this image with SunPy as well as other Python libraries, so that you can generate a coordinate system for your image. As we will show, this allows you to combine your eclipse images with solar observations such as those from NASA’s Solar Dynamics Observatory.

[1]:

from pathlib import Path

import astropy.units as u
import exifread
import matplotlib.image
import matplotlib.pyplot as plt
import numpy as np
import sunpy.coordinates
import sunpy.coordinates.sun
from astropy.constants import R_earth
from astropy.coordinates import CartesianRepresentation, EarthLocation, SkyCoord

# We have defined a few helper functions in this `eclipse_helpers.py` file.
from eclipse_helpers import SOLAR_ECLIPSE_IMAGE, get_camera_metadata
from matplotlib.patches import Circle
from scipy import ndimage
from skimage.color import rgb2gray
from skimage.feature import peak_local_max
from skimage.transform import hough_circle, hough_circle_peaks
from sunpy.map.header_helper import make_fitswcs_header
from sunpy.net import Fido
from sunpy.net import attrs as a
from sunpy.time import parse_time

Read in Your Eclipse Photo

The first step is to read in our image. As mentioned above, we will be using an image taken during the 2017 eclipse taken with a consumer-grade camera. When reading in our image data, we’ll invert the y-axis and convert it to a grayscale image.

[2]:

im_rgb = np.flipud(matplotlib.image.imread(SOLAR_ECLIPSE_IMAGE))
im = rgb2gray(im_rgb)

/Users/nabil/micromamba/envs/sunpy-dev/lib/python3.13/site-packages/skimage/color/colorconv.py:984: RuntimeWarning: divide by zero encountered in matmul
  return rgb @ coeffs
/Users/nabil/micromamba/envs/sunpy-dev/lib/python3.13/site-packages/skimage/color/colorconv.py:984: RuntimeWarning: overflow encountered in matmul
  return rgb @ coeffs
/Users/nabil/micromamba/envs/sunpy-dev/lib/python3.13/site-packages/skimage/color/colorconv.py:984: RuntimeWarning: invalid value encountered in matmul
  return rgb @ coeffs

[3]:

plt.imshow(im, origin="lower", cmap="gray")
plt.show()

In order to be able to align our image with solar images from NASA, we will also need some additional metadata from our image. The two most important things we need to know are:

the GPS coordinates of where the photo was taken and
the time the image was taken

We can pull this metadata from the file and then use an additional function we wrote to process this metadata into a Python dictionary.

[4]:

with Path(SOLAR_ECLIPSE_IMAGE).open("rb") as f:
    tags = exifread.process_file(f)

[5]:

camera_metadata = get_camera_metadata(tags)

As it turns out, the time on the camera used to take this eclipse photo was wrong, we have to manually correct it.

[6]:

camera_metadata["time"] = parse_time("2017-08-21 17:27:13")

Find the Moon

Now that we’ve loaded our image and accompanying metadata, the next step is to locate the edge of the Moon in our image. This allows us to find the center of the Moon, which is needed when aligning our data, as well as allowing us to determine the scale of the Moon in the image. In order to do this we are going to use several different image manipulation techniques.

We start with applying a Gaussian blur to help segment the lunar disk from the corona and mask all parts of the image above a given threshold.

[7]:

blur_im = ndimage.gaussian_filter(im, 8)
mask = blur_im > blur_im.mean() * 3
plt.imshow(mask)
plt.show()

We then label those masked regions and select only the parts of the image that correspond to the bright, diffuse corona.

[8]:

label_im, nb_labels = ndimage.label(mask)
slice_y, slice_x = ndimage.find_objects(label_im == 1)[0]
roi = blur_im[slice_y, slice_x]

The next step is to detect the inner edge of the bright corona. To do this, we apply a Sobel filter in both the x and y directions, and then calculate a single image from the two directions.

[9]:

sx = ndimage.sobel(roi, axis=1, mode="constant")
sy = ndimage.sobel(roi, axis=0, mode="constant")
sob = np.hypot(sx, sy)

Finally, we use scikit-image to apply the Hough Transform to identify circles in the image. We then use this to extract the size in pixels of the lunar disk and its center.

[10]:

hough_radii = np.arange(np.floor(np.mean(sob.shape) / 4), np.ceil(np.mean(sob.shape) / 2), 10)
hough_res = hough_circle(sob > (sob.mean() * 5), hough_radii)

# Select the most prominent circle
accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=1)

As shown below, we now have a list of pixel coordinates corresponding to the solar limb in our image. The first frame is the cropped original image. The middle frame is the Sobel filtered image used to apply the Hough transform. The right frame is the fitted circle on the original image.

[11]:

fig, ax = plt.subplots(ncols=3, nrows=1, figsize=(9.5, 6))
ax[0].imshow(im[slice_y, slice_x])
ax[0].set_title("Original")
ax[1].imshow(sob > (sob.mean() * 5))
ax[1].set_title("Sobel")
circ = Circle(
    [cx, cy], radius=radii, facecolor="none", edgecolor="red", linewidth=2, linestyle="dashed", label="Hough fit"
)
ax[2].imshow(im[slice_y, slice_x])
ax[2].add_patch(circ)
ax[2].set_title("Original with fit")
plt.legend()
plt.show()

Lastly, let’s add units to our circle that we fit the lunar limb.

[12]:

im_cx = (cx[0] + slice_x.start) * u.pix
im_cy = (cy[0] + slice_y.start) * u.pix
im_radius = radii[0] * u.pix

Make a SunPy `Map`

At this point, we have our image data, it’s metadata and we’ve located the Moon. Now we are ready to load our eclipse photograph into a SunPy Map! A Map allows us to carry around both the data and metadata of our image together and, importantly, makes it easy to combine solar observations from multiple observatories.

First, we define the observer location (i.e., where on Earth did we take our picture?) and the orientation of the Sun in the sky. For the observer location, we can use the GPS coordinates from our image metadata.

[13]:

loc = EarthLocation(lat=camera_metadata["gps"][0], lon=camera_metadata["gps"][1], height=camera_metadata["gps"][2])
observer = loc.get_itrs(camera_metadata["time"])

Second, we determine the angular size of the Moon using its radius and its distance from the observer.

[14]:

moon = SkyCoord(sunpy.coordinates.get_body_heliographic_stonyhurst("moon", camera_metadata["time"], observer=observer))
R_moon = 0.2725076 * R_earth  # IAU mean radius
dist_moon = SkyCoord(observer).separation_3d(moon)
moon_obs = np.arcsin(R_moon / dist_moon).to("arcsec")
print(moon_obs)

2025-06-23 09:08:55 - sunpy - INFO: Apparent body location accounts for 1.23 seconds of light travel time

INFO: Apparent body location accounts for 1.23 seconds of light travel time [sunpy.coordinates.ephemeris]
975.9073137731282 arcsec

Combining this angular radius with the radius of the lunar disk in pixels gives us the angular size of the pixels in the image. In the parlance of astronomical imaging, this is often referred to as the plate scale.

[15]:

plate_scale = moon_obs / im_radius
print(plate_scale)

4.356729079344322 arcsec / pix

We also use the observer location to calculate the orientation of the Sun as seen from that location on Earth. This gives us a rotation angle between our image coordinate system and the solar north pole. If your camera is not perfectly horizontal then you may need to fudge this value slightly.

[16]:

solar_rotation_angle = sunpy.coordinates.sun.orientation(loc, camera_metadata["time"])
print(solar_rotation_angle)

-54d19m44.13467961s

Finally we have all the information we need to build a sunpy Map for our eclipse image.

[17]:

frame = sunpy.coordinates.Helioprojective(observer=observer, obstime=camera_metadata["time"])
moon_hpc = moon.transform_to(frame)

header = make_fitswcs_header(
    im,
    moon_hpc,
    reference_pixel=u.Quantity([im_cx, im_cy]),
    scale=u.Quantity([plate_scale, plate_scale]),
    rotation_angle=solar_rotation_angle,
    exposure=camera_metadata.get("exposure_time"),
    instrument=camera_metadata.get("camera_model"),
    observatory=camera_metadata.get("author"),
)

[18]:

eclipse_map = sunpy.map.Map(im, header)

[19]:

fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(projection=eclipse_map)
eclipse_map.plot(axes=ax)
plt.show()

Find a Star

Though we already have all of the metadata we need to make a SunPy Map, we can further improve the accuracy by locating a known star in the image and using that to determine the rotation angle. In the case of the 2017 eclipse the very bright star (magnitude 1.4) Regulus was close to the Sun and in the field of view of our photograph. For the 2024 eclipse, no such bright star will be visible, which may make this method of aligning your image challenging. The best candidate looks to be Alpha Piscium which is a binary system with a combined magnitude of 3.82, significantly dimmer than Regulus. You can see the stars close to the Sun by using Stellarium.

As Regulus is a well known star, we can create a coordinate object for it, including its distance.

[20]:

regulus = SkyCoord(ra="10h08m22.311s", dec="11d58m01.95s", distance=79.3 * u.lightyear, frame="icrs")
print(regulus)

<SkyCoord (ICRS): (ra, dec, distance) in (deg, deg, lyr)
    (152.0929625, 11.96720833, 79.3)>

We can then plot the expected location of Regulus on our eclipse image. We set the scaling such that it make Regulus more visible and zoom in on the relevant part of the field of view. You can see that the expected location and the actual location are quite different.

[21]:

fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(projection=eclipse_map)
eclipse_map.plot(axes=ax, clip_interval=(0, 90) * u.percent)
ax.plot_coord(
    regulus, "o", markeredgewidth=0.5, markeredgecolor="w", markerfacecolor="None", markersize=10, label="Regulus"
)
plt.legend()
plt.xlim(100, 500)
plt.ylim(0, 500)
plt.show()

Given this offset, we want to fix our image metadata such that the actual and expected locations of Regulus are line up. We can calculate the expected distance from the center of the Sun to Regulus in pixels.

[22]:

regulus_pixel = CartesianRepresentation(*eclipse_map.wcs.world_to_pixel(regulus), 0) * u.pix
sun_pixel = (
    CartesianRepresentation(*eclipse_map.wcs.world_to_pixel(SkyCoord(0 * u.arcsec, 0 * u.arcsec, frame=frame)), 0)
    * u.pix
)
regulus_r = (regulus_pixel - sun_pixel).norm()
print(regulus_r)

1084.0811009031981 pix

We then use this to find Regulus in our image, by filtering out all pixels which are closer to the Sun than this.

[23]:

pix_x = np.arange(eclipse_map.dimensions[0].value) * u.pix - sun_pixel.x
pix_y = np.arange(eclipse_map.dimensions[1].value) * u.pix - sun_pixel.y
xx, yy = np.meshgrid(pix_x, pix_y)
r = np.sqrt(xx**2 + yy**2)

filter_r = regulus_r - (regulus_r / 5)

masked = im.copy()
masked[r < filter_r] = masked.min()

Having masked out most of the Sun and its corona, we now find the highest peak remaining, which should be Regulus.

[24]:

regulus_y, regulus_x = peak_local_max(masked, min_distance=2, num_peaks=1)[0]
actual_regulus_pixel = CartesianRepresentation(regulus_x, regulus_y, 0) * u.pix

We can now compare the identified pixel coordinates of Regulus to the expected coordinates assuming the camera was exactly horizontal.

[25]:

print(actual_regulus_pixel)
print(regulus_pixel)

(372., 247., 0.) pix
(339.45349652, 307.65804366, 0.) pix

Finally, we calculate the angular offset between our expected location and our identified location and then add this difference to correct our solar rotation angle.

[26]:

vec_expected = regulus_pixel - sun_pixel
vec_actual = actual_regulus_pixel - sun_pixel
fudge_angle = -np.arccos(vec_expected.dot(vec_actual) / (vec_expected.norm() * vec_actual.norm()))
print(fudge_angle.to(u.deg))

-3.5738144694153595 deg

We then use this correction factor to build a new Map for our image with updated metadata.

[27]:

header = make_fitswcs_header(
    im,
    moon_hpc,
    reference_pixel=u.Quantity([im_cx, im_cy]),
    scale=u.Quantity([plate_scale, plate_scale]),
    rotation_angle=solar_rotation_angle + fudge_angle,
    exposure=camera_metadata["exposure_time"],
    instrument=camera_metadata["camera_model"],
)

[28]:

eclipse_map = sunpy.map.Map(im, header)

Plotting our image again, we now find that the identified location of Regulus and our image line up much better.

[29]:

fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(projection=eclipse_map)
eclipse_map.plot(axes=ax, clip_interval=(0, 90) * u.percent)
ax.plot_coord(
    regulus, "o", markeredgewidth=0.5, markeredgecolor="w", markerfacecolor="None", markersize=10, label="Regulus"
)
plt.legend()
plt.xlim(100, 500)
plt.ylim(0, 500)
plt.show()

Combine your Image with NASA Data

As mentioned above, one of the main advantages of having data in a Map is that it is then easy to combine observations from multiple different sources. Let’s overlay an AIA image from the SDO satellite. We’ll choose an image that shows extreme ultraviolet emission from the corona, revealing plasma that is around one million degrees. Fortunately, all SDO data is publicly available and SunPy provides a convenient interface for searching for and downloading this data.

[30]:

aia_result = Fido.search(
    a.Time("2017-08-21 17:27:00", "2017-08-21 17:45:00", eclipse_map.date),
    a.Instrument("AIA"),
    a.Wavelength(171 * u.Angstrom),
)
print(aia_result)

Results from 1 Provider:

1 Results from the VSOClient:
Source: https://sdac.virtualsolar.org/cgi/search
Data retrieval status: https://docs.virtualsolar.org/wiki/VSOHealthReport
Total estimated size: 67.789 Mbyte

       Start Time               End Time        Source Instrument   Wavelength   Provider  Physobs  Wavetype Extent Width Extent Length Extent Type   Size
                                                                     Angstrom                                                                        Mibyte
----------------------- ----------------------- ------ ---------- -------------- -------- --------- -------- ------------ ------------- ----------- --------
2017-08-21 17:27:09.000 2017-08-21 17:27:10.000    SDO        AIA 171.0 .. 171.0     JSOC intensity   NARROW         4096          4096    FULLDISK 64.64844

[31]:

aia_result[0, 0]

[31]:

QueryResponseRow index=0

Start Time	End Time	Source	Instrument	Wavelength	Provider	Physobs	Wavetype	Extent Width	Extent Length	Extent Type	Size	fileid
				Angstrom							Mibyte
Time	Time	str3	str3	float64[2]	str4	str9	str6	str4	str4	str8	float64	str24
2017-08-21 17:27:09.000	2017-08-21 17:27:10.000	SDO	AIA	171.0 .. 171.0	JSOC	intensity	NARROW	4096	4096	FULLDISK	64.64844	aia__lev1:171:1282411667

[32]:

files = Fido.fetch(aia_result[0, 0], site="NSO")

[33]:

files

[33]:

<parfive.results.Results object at 0x158950690>
['/Users/nabil/sunpy/data/aia.lev1.171A_2017_08_21T17_27_09.35Z.image_lev1.fits']

Having downloaded this data we create a SunPy Map and then plot it on top of our eclipse image. Note that despite not being in the same coordinate system, our AIA Map is automatically transformed to the coordinate system of our image before plotting.

[34]:

aia_map = sunpy.map.Map(files[0])

[35]:

fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(projection=eclipse_map)
eclipse_map.plot(axes=ax)
aia_map.plot(axes=ax, autoalign=True)
aia_map.draw_grid(axes=ax)
plt.show()

2025-06-23 09:09:07 - sunpy - INFO: Using mesh-based autoalignment

INFO: Using mesh-based autoalignment [sunpy.map.mapbase]

Conclusion

In this blog post, we demonstrated how to read your eclipse images into a SunPy Map and how to combine your own photographs with data from NASA observations of the Sun. Though this post used data from the 2017 eclipse, you should be able to use the same techniques to process your 2024 eclipse observations. Happy eclipse viewing!

SunPy Awarded NASA Grant

2021-11-03T00:00:00+00:00

As part of the NASA “Open Source Tools, Frameworks, and Libraries” program, the SunPy proposal “Strengthening the Foundations of the SunPy Ecosystem” has been funded for the next three years.

This proposal was submitted in January 2021, and sought funding for both the core sunpy package and wider goals of the project. After early community input was collected, Albert Shih led the proposal itself, with NASA GSFC as the primary institution. The proposed effort focuses on three main areas:

Improving the technical infrastructure.

This focuses on the tools that the wider project needs to scale up as we adopt more coordinated and affiliated packages. To support multiple active projects with a common development workflow, more tooling and infrastructure is needed, both for maintainers of existing packages and developers new to writing affiliated packages. As part of this work templates for setting up new packages will be improved, documentation will be written, and new automation and monitoring bots will be developed to ease the burden on the SunPy maintainers.
Augmenting science-enabling functionality.

This section aims to improve the tools provided by the core package to better support future challenges in solar physics data. The two main components of this are supporting multi-point observations with improvements to the sunpy.coordinates package, and improving the support for very large datasets in sunpy and sponsored packages by leveraging the scaling and parallelism tools available from Dask.
Providing training and outreach

This section will improve example galleries across both sunpy core and affiliated packages, develop training materials for solar physics graduate students, and perform outreach activities with instrument teams and package developers.

What will the money pay for?

The money awarded to this proposal will pay for:

Albert Shih will manage the project and augment parts of sunpy.coordinates.
Stuart Mumford will work on infrastructure for all sponsored and affiliated packages as discussed in sunpy/sunpy-project#2.
Will Barnes will work on the training/outreach and large-dataset-support components of the project.

Finally

This is a major milestone for SunPy - it is the first significant amount of funding dedicated to directly working on the long term sustainability of the project. This funding will help to significantly grow SunPy, both the core package and the ecosystem of associated packages.

October Release Announcements

2021-10-29T00:00:00+00:00

Today we have a quadruple release announcement for you! It’s been a very busy week in SunPy land getting both the core and ndcube releases over the line; I hope you enjoy them!

sunpy 3.1

The next scheduled release of the sunpy core package actually comes a week early according to our release calendar, but we couldn’t resist bringing you this end of month release party.

The 3.1 release contains many new features and improvements, having merged 145 pull requests from 16 people including 8 new contributors.

Some of the highlights from the What’s New in SunPy 3.1? page are:

Increased in-situ data support
A new limb drawing function
A new WISPR map source
Propagating solar-surface coordinates in time
Convenient reprojection of maps
JSOC keyword filtering with Fido
Arithmetic operations with maps

My personal favourites being the new limb drawing function and the reproject_to method on all maps.

ndcube 2.0

Even more excitingly, for me personally, is the long awaited 2.0 release of ndcube.

ndcube is the sunpy sponsored package for working with multi-dimensional data with an associated WCS object. For an introduction to ndcube and motivation for the 2.0 rework see An introduction to ndcube.

We started working on ndcube 2.0 back in 2019 when we had Yash Sharma do the initial work of porting the code base to use the APE 14 APIs as his Google Summer of Code project. Little did any of us think that it would take over two years from that point to hit the final release.

The road to ndcube 2.0 has been long and arduous; all involved have put in a lot of work and what we have made is something that I am personally very proud of. ndcube 2.0 would not have happened without Dan Ryan, who as the co-maintainer for ndcube has spent many hours on video calls with me designing APIs, and many more hours besides working out problems you would only encounter in one in a million WCS objects! I would also be remiss if I didn’t specifically thank the DKIST data center who have, by paying for my time, funded a lot of the development work on ndcube 2.0, even when the scope increased beyond their direct requirements.

I hope that many packages will start using ndcube 2.0 as the base for their code. There are already many who have helped to shape the release such as the DKIST User Tools, specutils and sunraster as well as others I know are in the works.

For all the gory details of the changes in ndcube 2.0 see the changelog.

pfsspy 1.0

The SunPy-affiliated potential field source surface extrapolation package pfsspy maintained by David Stansby has had a 1.0 release, which includes promises of API stability. You can read about all the changes in the changelog.

aiapy 0.6

The SunPy-affiliated aiapy package, which provides tools for working with SDO/AIA data and is maintained by the AIA instrument team, has a new 0.6 release which includes support for sunpy core 3.1. In addition to a number of bug fixes, v0.6 also includes the ability to calculate uncertainties on AIA images via the estimate_error function. A complete list of changes is available in the changelog.

SunPy 2.0 Released

2020-06-12T00:00:00+00:00

The SunPy project is happy to announce the release of SunPy 2.0! SunPy is an open-source Python library for Solar Physics data analysis and visualization.

This release is our second long(er) term support release, that we will be supporting with bug fixes until 3.0 in roughly a year’s time. With this release, the 1.0 and 1.1 releases will no longer receive bug fixes and we encourage everyone to upgrade to 2.0.

The major highlights of this release are:

Fido now supports tab completion of search attributes. This allows you to do a.Instrument.AIA, and print a.Instrument to see the list of known supported instruments.
aiaprep has been deprecated in favor of the functionality in the aiapy package.
Various fixes and clarifications to pixel indexing in the sunpy.map subpackage.
Standardization of specifying rectangles in coordinate space in the submap() and draw_rectangle() methods of GenericMap.
HTML quicklook previews of GenericMap and MapSequence instances are available with the new quicklook() and quicklook() methods, respectively. This is also the default display in Jupyter notebooks.
Integration of differential rotation into the sunpy.coordinates framework. This enables, amongst other things, the warping of images with the reproject package and the plotting of rotated grid lines with WCSAxes.

See What’s New in SunPy 2.0 for more details and the Full Changelog for the full list of over 100 changes in 2.0.

This release of SunPy contains 1044 commits in 290 merged pull requests closing 144 issues from 33 people, 16 of which are first-time contributors to SunPy.

The people who have contributed to the code for this release are:

Abhijeet Manhas * Abijith B * Albert Y. Shih Amogh J * Arfon Smith * Arib Alam * David Pérez-Suárez David Stansby Deepankar Sharma Jack Ireland Jai Ram Rideout James Paul Mason Kris Akira Stern * Laura Hayes Lazar Zivadinovic * Mark Cheung * Monica Bobra Nabil Freij Ole Streicher Pankaj Mishra * Raahul Singh Rajiv Ranjan Singh Rutuja Surve * Sarthak Jain Sashank Mishra * Steven Christe Stuart Mumford Swapnil Kannojia * Utkarsh Parkhi * Will Barnes abijith-bahuleyan * honey * mridulpandey *

Where a * indicates their first contribution to SunPy.

SunPy 1.1 Released

2020-01-10T00:00:00+00:00

The SunPy project is happy to announce the release of SunPy 1.1! SunPy is an open-source Python library for Solar Physics data analysis and visualization.

This release is our first major release post-1.0 and part of our new release pattern.

The major highlights of this release are:

The coordinates subpackage now supports four additional coordinate frames (HCI, HEE, GSE, and GEI).
A new subpackage sunpy.data.data_manager has been added to support versioned data for functions and methods.
Support in sunpy.map and sunpy.net for the SUVI instrument on GOES satellites.
Initial support for WISPR data from Parker Solar Probe in sunpy.map.
The import times for sunpy and some subpackages are significantly shorter, with no loss of functionality.

See What’s New in SunPy 1.1 for more details and the Full Changelog for the full list of over 100 changes in 1.1.

If you use conda, you can update to this release by running:

$ conda install -c conda-forge sunpy

or, if you use pip, by running:

$ pip install -U sunpy

If you haven’t already installed SunPy we recommend you follow our Installation Guide.

By the numbers

This release of SunPy contains 1137 commits in 242 merged pull requests closing 106 issues from 24 people, 10 of which are first time contributors to SunPy.

The people who have contributed to the code for this release are:

Albert Y. Shih
Arthur Eigenbrot
Brigitta Sipocz
David Pérez-Suárez
David Stansby
Dominik Stańczak *
Guntbert Reiter *
Himanshu Pathak *
Jack Ireland
Juanjo Bazán *
Laura Hayes
Michael S Kirk
Nabil Freij
Quinn Arbolante *
Raahul Singh *
Rajiv Ranjan Singh *
Steven Christe
Stuart Mumford
Tom Augspurger *
Vishnunarayan K I.
Will Barnes
Yash Sharma
neerajkulk *

Where a * indicates their first contribution to SunPy.

Happy Pythoning,

Stuart

SunPy Release Schedule and Version Numbering

2019-06-27T00:00:00+00:00

In this blog post I want to outline how, and more over why, we are going to number the SunPy releases and when we are going to release them.

TLDR; we are going to move to a 6 month release cadence, with a Long Term Support (one year of support) release in May and a Short Term Support (6 months of support) in November. We will increment the major version number for each LTS release.

Background

As part of the 1.0 release planning the SunPy developers and the board spent a long time discussing how we want to version SunPy and what we want to use our versioning a release schedule to achieve. We went through two major iterations of this plan, the first can be found in the abandoned PR to the SunPy Enhancement Proposal repository #30, and the second one which was accepted in #40.

Objectives

In moving SunPy out of the 0.y series of releases we knew that our users would be expecting us to make breaking changes less, and for them to be able to rely on SunPy for longer.

We wanted to balance the desire for people to be able to start using SunPy for a project and be able to see that project through without having to constantly adjust to many changes in new releases. On the other hand, we wanted to also allow the development of SunPy to continue without having to delay people contributing improvements to SunPy because of a strict versioning scheme.

We also have to consider that, currently, SunPy core is developed entirely by volunteers, and supporting old versions of the library is a time consuming and sometimes thankless job.

Releases

The solution we landed on is to provide a Long Term Support release that we will support for one year (i.e. until the following LTS release). This gives people who want stability a release schedule where they get bug fixes for a year. While also allowing SunPy to do releases on a six month cycle to get new features out for people to use.

To make it clear which releases are Long Term Support releases, we will increment the major version (the first number) for each LTS release. This means SunPy 1.0 is a LTS release which we will be supporting until the release of 2.0 in May 2020.

The all the non-LTS releases between the LTS releases will increment the minor version number, as there is only one release planned between LTS releases the normal release number will be 1.0, 1.1, 2.0, 2.1 etc.

Deprecations

We still expect, and have plans for, changes to many parts of SunPy. We believe these changes will enable even more people to find SunPy useful in their work.

To enable people to prepare for changes and to not be in for big surprises when updating SunPy we will endeavour to emit a deprecation warning for any breaking changes for one LTS release.

The upshot of this is that, if now after 1.0, we want to change something in a backwards incompatible way we would continue to provide both the old and new ways until after the 2.0 release. The 2.0 release would emit a deprecation warning, to give people who go from LTS to LTS a year to update their code before the next LTS.

Conclusion

I hope this blog post gives you some insight into how we made this decision and why, if you have any comments please don’t hesitate to get in touch using any of the usual ways.

SunPy 1.0 Released

2019-06-01T00:00:00+00:00

The SunPy project is happy to announce the release of SunPy 1.0.0!

This release has been in development for 14 months, and is a large change from the 0.x series of SunPy releases with a lot of old functionality removed and some exciting new features.

The major highlights of this release are:

A complete transition of the whole code base to use astropy.time.Time, which was implemented by Vishnunarayan K I as part of Google Summer of Code 2018.
A rewrite of how all the clients in sunpy.net download files from the internet. This means vastly improved progress bars, skipping downloads if files are present, and better visibility and retrying of download errors.
A rewrite of the differential rotation and image warping code to correctly account for observer location using the Astropy coordinate functionality.
Removal of many deprecated functions and submodules; we have used the 1.0 release as a chance to clean out SunPy reducing the number of lines of Python code in the project by almost 3,000!
The first release of SunPy to be Python 3 only, requiring Python 3.6+.

See What’s New in SunPy 1.0 for more details and the Full Changelog for the full list of over 150 changes in SunPy 1.0.

This release includes many breaking changes and may require your code to be updated to support it. We hope you see the value in having the extra features these changes have enabled and a code base that is easier to maintain. We will be continuing to release bug fixes to the 0.9.z series until the end of 2019. We hope this gives you enough time to update your code and start enjoying all the improvements in SunPy 1.0.

If you use conda, you can update to this release by running:

$ conda install -c conda-forge sunpy

or, if you use pip, by running:

$ pip install -U sunpy

If you haven’t already installed SunPy we recommend you follow our Installation Guide.

By the numbers

This release of SunPy contains 1913 commits in 332 merged pull requests closing 582 issues from 46 people, 25 of which are first time contributors to SunPy.

The people who have contributed to the code for this release are:

Abhigyan Bose *
Airmansmith97 *
Albert Y. Shih
Andre Chicrala *
Andrew Hill *
Andrew Inglis
Andrew Leonard
Arthur Eigenbrot *
Bernhard M. Wiedemann *
Brandon Stone *
Brigitta Sipocz
Daniel D’Avella
Daniel Ryan
David Pérez-Suárez
David Stansby
Deepankar Sharma *
Emmanuel Arias *
Harsh Mathur *
Jack Ireland
Jacob *
Jai Ram Rideout *
Larry Manley
Laura Hayes *
Manas Mangaonkar *
Matthew Mendero *
Md Akramul Haque *
Michael S Kirk
Mickaël Schoentgen *
Monica Bobra *
Nabil Freij
Naman9639 *
Prateek Chanda
Punyaslok Pattnaik
Reid Gomillion *
Sarthak Jain *
Shane Maloney
Shresth Verma
Sourav Ghosh *
Steven Christe
Stuart Mumford
Vishnunarayan K I.
Will Barnes
Yash Jain
Yash Krishan *
Yash Sharma *
jamescalixto *

Where a * indicates their first contribution to SunPy.

On a personal note, I am very excited to see SunPy reach this milestone; watching the community around this project grow since I got involved has been incredible. The sunpy library is almost unrecognisable from where it was when I got involved shortly after the 0.2 release, which is the result of countless hours of work by over 100 people. I want to thank everyone who has contributed to SunPy in any way that helped us get to the point where we felt the library deserved the 1.0 label. I especially want to thank Nabil Freij who has done so much behind the scenes work to keep things moving forward, and done such a good job helping new contributors get pull requests into SunPy.

I am very excited to see where SunPy goes next.

Happy Pythoning,

Stuart

SunPy 0.9 Released

2018-04-24T00:00:00+00:00

The SunPy project is very happy to announce the release of SunPy 0.9, the latest release of the SunPy core package.

SunPy 0.9 brings improved support for downloading data from the JSOC and bugfixes compared to the 0.8.x series of releases. The 0.9.x series will be the last series of SunPy releases to support Python 2. This is because Python 2 will not be maintained after 2019. The 0.9.x series will receive bugfixs only up until the and of life of Python 2 (around 18 months). No new functionality will be added to the 0.9.x series, which will also be the last version to include sunpy.spectra, sunpy.lightcurve and sunpy.wcs, all of which were deprecated in 0.8.

SunPy 1.0 and higher will support Python 3 only. All new functionality will be available only in SunPy 1.0 and higher.

SunPy v0.9.0 contains 807 commits in 147 merged pull requests closing 310 issues from 31 people, 19 of which are first time contributors to SunPy.

The people who have contributed to the code for this release are

Nabil Freij
Stuart Mumford
Nitin Choudhary
David Stansby *
Prateek Chanda
Jack Ireland
Daniel Ryan
Himanshu *
Yash Jain *
James Paul Mason *
Michael Charlton
Vishnunarayan K I. *
Swapnil Sharma *
Albert Y. Shih
David Pérez-Suárez
Shresth Verma *
Sanjeev Dubey *
Brigitta Sipocz
Andrew Leonard
Nick Murphy *
Shane Maloney
Carlos Molina *
Yash Kothari *
Dang Trung Kien *
Gulshan Mittal *
Rajasekhar Reddy Mekala *
S Shashank *
Tannmay Yadav *
Will Barnes *
Yudhik Agrawal *
codetriage-readme-bot *

Where a * indicates their first contribution to SunPy.

In addition to the contributions to the core SunPy library, we would like to thank Kolja Glogowski for his help with the JSOC project, and welcome his package ‘drms’ as a SunPy affiliated package, which is now powering our JSOC client. Finally, we would like to thank David Pérez-Suárez and Brigitta Sipocz, who are leading the GSOC process for OpenAstronomy, which is of massive benefit to the SunPy community.

SunPy 0.9 can be installed from pip or conda using the following commands

using conda:

$ conda config channels --append conda-forge
$ conda install sunpy

or using pip:

$ pip install sunpy

and updated using conda:

$ conda update sunpy

or pip:

$ pip install -U sunpy

NDCube 1.0 Released

2018-02-25T00:00:00+00:00

The SunPy project is very happy to announce the release of a new package “ndcube”.

ndcube is a package built for handling, inspecting and visualizing a wide variety of data, of any number of dimensions, along with coordinate information described by FITS-WCS. The NDCube object is based on the astropy NDData class, and adds functionality for slicing both the data and the WCS simultaneously, plotting with matplotlib and support for extra coordinate information along any of the axes not described by WCS.

In addition to this the ndcube package provides the NDCubeSequence class for representing sequences of NDCube objects where the coordinate information may or may not align, and accessing these sequences in a way consistent with a singular cube.

The ndcube development has been lead by Daniel Ryan with contributions from the following people:

Daniel Ryan
Ankit Baruah
Stuart Mumford
Mateo Inchaurrandieta
Nabil Freij
Drew Leonard
Shelbe Timothy

A lot of the design and development of ndcube was done as part of Ankit’s Google Summer of Code project in the summer of 2017.

For more information about ndcube see the documentation.

ndcube can be installed from pip or conda using the following commands:

$ conda install -c conda-forge ndcube

$ pip install ndcube

Blog - Posts by Stuart Mumford

Artemis II Solar Eclipse

Fitting Coordinate Information

Finding the position of Artemis II

Moon Limb Fitting

Calculating Image Scale

Fitting Roll Angle

Fitting Lens Distortion

Overplotting Coronagraph Images

Process Your Solar Eclipse Photos with SunPy!

Read in Your Eclipse Photo

Find the Moon

Make a SunPy Map

Find a Star

Combine your Image with NASA Data

Conclusion

SunPy Awarded NASA Grant

What will the money pay for?

Finally

October Release Announcements

sunpy 3.1

ndcube 2.0

pfsspy 1.0

aiapy 0.6

SunPy 2.0 Released

SunPy 1.1 Released

By the numbers

SunPy Release Schedule and Version Numbering

Background

Objectives

Releases

Deprecations

Conclusion

SunPy 1.0 Released

By the numbers

SunPy 0.9 Released

NDCube 1.0 Released

Make a SunPy `Map`