def test_read_header():
"""
Tests the reading of the JP2 header.
"""
from sunpy.io.jp2 import get_header
header = get_header(AIA_193_JP2)[0]
assert isinstance(header, FileHeader)
def bbox_viz(img, X, Y):
"""
This function takes image and solar event coordinate and then reutns the image object with a bounding-box
:param img: image url of a fits file
:param X: x coordinate arcsec
:param Y: y coordinate arcsec
:return: image object
"""
h = jp2.get_header(img)
header = h[0]
image_w = header['NAXIS1']
image_h = header['NAXIS2']
center_x = header['CRPIX1']
center_y = header['CRPIX2']
scale_x = header['CDELT1']
scale_y = header['CDELT2']
PixX = (center_x + (X / scale_x))
PixY = (center_y - (Y / scale_y))
im = Image.open(img)
offset = 100
left = PixX - offset
top = PixY - offset
right = PixX + offset
bottom = PixY + offset
source_img = Image.open(img).convert("RGBA")
draw = ImageDraw.Draw(source_img)
draw.rectangle(((left, top), (right, bottom)), outline="yellow", width=4)
return source_img
def test_read_header():
"""
Tests the reading of the JP2 header.
"""
from sunpy.io.jp2 import get_header
header = get_header(AIA_193_JP2)[0]
assert isinstance(header, FileHeader)
def header(file_path):
"""
This function takes the JP2 file path as input and returns the spatial header info of that file.
:param file_path: full path of the .jp2 file
:return: spatial header info
"""
h = jp2.get_header(file_path)
header = h[0]
image_w = header['NAXIS1']
image_h = header['NAXIS2']
center_x = header['CRPIX1']
center_y = header['CRPIX2']
scale_x = header['CDELT1']
scale_y = header['CDELT2']
header_spatial_info = [
image_w, image_h, center_x, center_y, scale_x, scale_y
]
return header_spatial_info
def read_header_only_but_still_use_sunpy_map(filepath):
"""
Reads the header for a JPEG200 file and returns some dummy data.
Why does this function exist? SunPy map objects perform some important
homogenization steps that we would like to take advantage of in
Helioviewer. The homogenization steps occur on the creation of the sunpy
map object. All SunPy maps have the same properties, some of which are
useful for Helioviewer to use in order to ingest JPEG2000 data. The SunPy
map properties are based on the header information in the JPEG2000 file,
which is a copy of the source FITS header (with some modifications in
some cases - see JP2Gen). So by using SunPy's maps, Helioviewer does not
have to implement these homogenization steps.
So what's the problem? Why not use SunPy's JPEG2000 file reading
capability? Well let's explain. SunPy's JPEG2000 file reading reads
both the file header and the image data. The image data is then decoded
ultimately creating a numpy array. The decoding step is computationally
expensive for the 4k by 4k images provided by AIA and HMI. It takes long
enough that the ingestion of AIA and HMI data would be severely impacted,
possibly to the point that we would never catch up if we fell behind in
ingesting the latest data.
The solution is to not decode the image data, but to pass along only the
minimal amount of information required to create the SunPy map. This
function implements this solution tactic, admittedly in an unsatisfying
manner. The actual image data is replaced by a 1 by 1 numpy array. This
is sufficient to create a SunPy map with the properties required by the
Helioviewer Project.
Parameters
----------
filepath : `str`
The file to be read.
Returns
-------
pairs : `list`
A (data, header) tuple
"""
header = get_header(filepath)
return [(np.zeros([1, 1]), header[0])]
def test_read_header():
"""Tests the reading of the JP2 header"""
header = get_header(AIA_193_JP2)[0]
assert isinstance(header, FileHeader)
def test_read_header():
header = get_header(AIA_193_JP2)[0]
assert isinstance(header, FileHeader)
