def _get_fov(self, ar_map):
"""
Find the field of view, taking into consideration the corners of the
original AR map and the loop coordinates in HPC.
"""
# Check magnetogram FOV
left_corner = (ar_map.bottom_left_coord.transform_to(
HeliographicStonyhurst).transform_to(
Helioprojective(observer=self.observer_coordinate)))
right_corner = (ar_map.top_right_coord.transform_to(
HeliographicStonyhurst).transform_to(
Helioprojective(observer=self.observer_coordinate)))
# Set bounds to include all loops and original magnetogram FOV (with some padding)
loop_coords = self.total_coordinates
if 'gaussian_width' in self.channels[0]:
width_max = u.Quantity(
[c['gaussian_width']['x'] for c in self.channels]).max()
pad_x = self.resolution.x * width_max
width_max = u.Quantity(
[c['gaussian_width']['y'] for c in self.channels]).max()
pad_y = self.resolution.y * width_max
else:
pad_x = self.resolution.x * 1 * u.pixel
pad_y = self.resolution.y * 1 * u.pixel
min_x = min(loop_coords.Tx.min(), left_corner.Tx) - pad_x
max_x = max(loop_coords.Tx.max(), right_corner.Tx) + pad_x
min_y = min(loop_coords.Ty.min(), left_corner.Ty) - pad_y
max_y = max(loop_coords.Ty.max(), right_corner.Ty) + pad_y
return min_x, max_x, min_y, max_y
def test_hpc_frame_to_wcs():
frame = Helioprojective(observer="earth", obstime='2013-10-28')
result_wcs = solar_frame_to_wcs_mapping(frame)
assert isinstance(result_wcs, WCS)
assert result_wcs.wcs.ctype[0] == 'HPLN-TAN'
assert result_wcs.wcs.cunit[0] == 'arcsec'
assert result_wcs.wcs.dateobs == '2013-10-28T00:00:00.000'
new_frame = solar_wcs_frame_mapping(result_wcs)
assert isinstance(new_frame.observer, HeliographicStonyhurst)
assert new_frame.rsun == frame.rsun
# Test a frame with no obstime and no observer
frame = Helioprojective()
result_wcs = solar_frame_to_wcs_mapping(frame)
assert isinstance(result_wcs, WCS)
assert result_wcs.wcs.ctype[0] == 'HPLN-TAN'
assert result_wcs.wcs.cunit[0] == 'arcsec'
assert result_wcs.wcs.dateobs == ''
new_frame = solar_wcs_frame_mapping(result_wcs)
assert new_frame.observer is None
assert new_frame.rsun == frame.rsun
def test_hpc_frame_to_wcs():
frame = Helioprojective(observer="earth",
obstime='2013-10-28',
rsun=690 * u.Mm)
result_wcs = solar_frame_to_wcs_mapping(frame)
assert isinstance(result_wcs, WCS)
assert result_wcs.wcs.ctype[0] == 'HPLN-TAN'
assert result_wcs.wcs.cunit[0] == 'arcsec'
assert result_wcs.wcs.dateobs == '2013-10-28T00:00:00.000'
assert result_wcs.wcs.aux.rsun_ref == frame.rsun.to_value(u.m)
new_frame = solar_wcs_frame_mapping(result_wcs)
assert new_frame.rsun == frame.rsun
# Test a frame with no obstime and no observer
frame = Helioprojective()
result_wcs = solar_frame_to_wcs_mapping(frame)
assert isinstance(result_wcs, WCS)
assert result_wcs.wcs.ctype[0] == 'HPLN-TAN'
assert result_wcs.wcs.cunit[0] == 'arcsec'
assert result_wcs.wcs.dateobs == ''
new_frame = solar_wcs_frame_mapping(result_wcs)
assert new_frame.observer is None
assert new_frame.rsun == frame.rsun
def test_hpc_low_precision_float_warning():
hpc = Helioprojective(u.Quantity(0, u.deg, dtype=np.float32),
u.Quantity(0, u.arcsec, dtype=np.float16),
observer=HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
with pytest.raises(SunpyUserWarning, match="Tx is float32, and Ty is float16"):
hpc.make_3d()
def test_hpc_distance_cartesian():
# Test detection of distance in other representations
hpc1 = Helioprojective(CartesianRepresentation(0 * u.km, 0 * u.km, 1 * u.Mm))
assert isinstance(hpc1, Helioprojective)
assert isinstance(hpc1._data, CartesianRepresentation)
assert hpc1.make_3d() is hpc1
def test_hpc_distance_3D():
hpc1 = Helioprojective(1500 * u.arcsec, 0 * u.arcsec, 100 * u.Mm)
assert isinstance(hpc1, Helioprojective)
# Check that we have a 2D wrap180 representation
assert isinstance(hpc1._data, SphericalRepresentation)
# Check the attrs are correct
assert hpc1.Tx == 1500 * u.arcsec
assert hpc1.Ty == 0 * u.arcsec
hpc2 = hpc1.make_3d()
assert hpc2 is hpc1
def translate_skycoord_to_other_map(clicked_skycoord):
global line_coords
#point_to_line = clicked_skycoord.realize_frame(clicked_skycoord.spherical * np.linspace(200, 213, 14) * u.solRad)
point_to_line = clicked_skycoord.realize_frame(
clicked_skycoord.spherical * np.linspace(0.5, 1.5, 1e6) * u.AU)
line_coords = point_to_line.transform_to(
Helioprojective(observer=maps[other_map].coordinate_frame.observer))
def identity_gwcs_4d():
"""
A simple 1-1 gwcs that converts from pixels to arcseconds
"""
identity = (m.Multiply(1 * u.arcsec / u.pixel)
& m.Multiply(1 * u.arcsec / u.pixel)
& m.Multiply(1 * u.nm / u.pixel)
& m.Multiply(1 * u.nm / u.pixel))
sky_frame = cf.CelestialFrame(
axes_order=(0, 1),
name='helioprojective',
reference_frame=Helioprojective(obstime="2018-01-01"))
wave_frame = cf.SpectralFrame(axes_order=(2, ), unit=u.nm)
time_frame = cf.TemporalFrame(axes_order=(3, ), unit=u.s)
frame = cf.CompositeFrame([sky_frame, wave_frame, time_frame])
detector_frame = cf.CoordinateFrame(name="detector",
naxes=4,
axes_order=(0, 1, 2, 3),
axes_type=("pixel", "pixel", "pixel",
"pixel"),
axes_names=("x", "y", "z", "s"),
unit=(u.pix, u.pix, u.pix, u.pix))
return gwcs.wcs.WCS(forward_transform=identity,
output_frame=frame,
input_frame=detector_frame)
def identity_gwcs_3d():
"""
A simple 1-1 gwcs that converts from pixels to arcseconds
"""
identity = (TwoDScale(1 * u.arcsec / u.pixel)
& m.Multiply(1 * u.nm / u.pixel))
sky_frame = cf.CelestialFrame(
axes_order=(0, 1),
name='helioprojective',
reference_frame=Helioprojective(obstime="2018-01-01"),
axes_names=("longitude", "latitude"),
unit=(u.arcsec, u.arcsec),
axis_physical_types=("custom:pos.helioprojective.lon",
"custom:pos.helioprojective.lat"))
wave_frame = cf.SpectralFrame(axes_order=(2, ),
unit=u.nm,
axes_names=("wavelength", ))
frame = cf.CompositeFrame([sky_frame, wave_frame])
detector_frame = cf.CoordinateFrame(name="detector",
naxes=3,
axes_order=(0, 1, 2),
axes_type=("pixel", "pixel", "pixel"),
axes_names=("x", "y", "z"),
unit=(u.pix, u.pix, u.pix))
wcs = gwcs.wcs.WCS(forward_transform=identity,
output_frame=frame,
input_frame=detector_frame)
wcs.pixel_shape = (10, 20, 30)
wcs.array_shape = wcs.pixel_shape[::-1]
return wcs
def identity_gwcs():
"""
A simple 1-1 gwcs that converts from pixels to arcseconds
Note this WCS does not have a correct axis correlation matrix.
"""
identity = m.Multiply(1 * u.arcsec / u.pixel) & m.Multiply(
1 * u.arcsec / u.pixel)
sky_frame = cf.CelestialFrame(
axes_order=(0, 1),
name='helioprojective',
reference_frame=Helioprojective(obstime="2018-01-01"),
unit=(u.arcsec, u.arcsec),
axis_physical_types=("custom:pos.helioprojective.lat",
"custom:pos.helioprojective.lon"))
detector_frame = cf.CoordinateFrame(name="detector",
naxes=2,
axes_order=(0, 1),
axes_type=("pixel", "pixel"),
axes_names=("x", "y"),
unit=(u.pix, u.pix))
wcs = gwcs.wcs.WCS(forward_transform=identity,
output_frame=sky_frame,
input_frame=detector_frame)
wcs.pixel_shape = (10, 20)
wcs.array_shape = wcs.pixel_shape[::-1]
return wcs
def test_on_frame(input):
hpc1 = Helioprojective(obstime=input)
output = Time('2012-01-01 00:00:00')
assert isinstance(hpc1.obstime, Time)
assert hpc1.obstime == output
def test_non_string():
output = parse_time('now')
hpc1 = Helioprojective(obstime=output)
assert isinstance(hpc1.obstime, Time)
assert hpc1.obstime == output
def test_angular_radius():
coord = Helioprojective(0 * u.deg,
0 * u.deg,
5 * u.km,
obstime="2010/01/01T00:00:00",
observer="earth")
assert_quantity_allclose(coord.angular_radius,
angular_radius(coord.obstime))
def test_angular_radius_no_observer():
coord = Helioprojective(0 * u.deg,
0 * u.deg,
5 * u.km,
obstime="2010/01/01T00:00:00",
observer=None)
with pytest.raises(ValueError,
match=r"The observer must be defined, not `None`"):
coord.angular_radius
def test_hpc_distance_off_limb():
hpc1 = Helioprojective(1500 * u.arcsec, 0 * u.arcsec,
observer=HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
assert isinstance(hpc1, Helioprojective)
# Check that we have a 2D wrap180 representation
assert isinstance(hpc1._data, UnitSphericalRepresentation)
# Check the attrs are correct
assert hpc1.Tx == 1500 * u.arcsec
assert hpc1.Ty == 0 * u.arcsec
with pytest.warns(SunpyUserWarning, match="is all NaNs"):
hpc2 = hpc1.make_3d()
assert isinstance(hpc2._data, SphericalRepresentation)
# Check the attrs are correct
assert hpc2.Tx == 1500 * u.arcsec
assert hpc2.Ty == 0 * u.arcsec
assert_quantity_allclose(hpc2.distance, u.Quantity(np.nan, u.km))
def test_coord_get():
# Test default (instance=None)
obs = Helioprojective.observer
assert obs is None
# Test get
obstime = "2013-04-01"
obs = Helioprojective(observer="earth", obstime=obstime).observer
earth = get_earth(obstime)
assert isinstance(obs, HeliographicStonyhurst)
assert_quantity_allclose(obs.lon, earth.lon)
assert_quantity_allclose(obs.lat, earth.lat)
assert_quantity_allclose(obs.radius, earth.radius)
assert hasattr(obs, "object_name")
assert obs.object_name == "earth"
assert str(obs) == "<HeliographicStonyhurst Coordinate for 'earth'>"
# Test get
obstime = "2013-04-01"
obs = Helioprojective(observer="earth", obstime=obstime).observer
earth = get_earth(obstime)
assert isinstance(obs, HeliographicStonyhurst)
assert_quantity_allclose(obs.lon, earth.lon)
assert_quantity_allclose(obs.lat, earth.lat)
assert_quantity_allclose(obs.radius, earth.radius)
# Test get mars
obstime = Time(parse_time("2013-04-01"))
obs = Helioprojective(observer="mars", obstime=obstime).observer
out_icrs = ICRS(get_body_barycentric("mars", obstime))
mars = out_icrs.transform_to(HeliographicStonyhurst(obstime=obstime))
assert isinstance(obs, HeliographicStonyhurst)
assert_quantity_allclose(obs.lon, mars.lon)
assert_quantity_allclose(obs.lat, mars.lat)
assert_quantity_allclose(obs.radius, mars.radius)
assert hasattr(obs, "object_name")
assert obs.object_name == "mars"
assert str(obs) == "<HeliographicStonyhurst Coordinate for 'mars'>"
def test_set_wcs_aux():
wcs = WCS(naxis=2)
observer = Helioprojective(observer="earth", obstime='2013-10-28').observer
_set_wcs_aux_obs_coord(wcs, observer)
assert wcs.wcs.aux.hgln_obs == 0
assert u.allclose(wcs.wcs.aux.hglt_obs, 4.7711570596394015)
assert u.allclose(wcs.wcs.aux.dsun_obs, 148644585949.4918)
assert wcs.wcs.aux.crln_obs is None
wcs = WCS(naxis=2)
observer = observer.transform_to(HeliographicCarrington(observer=observer))
_set_wcs_aux_obs_coord(wcs, observer)
assert wcs.wcs.aux.hgln_obs is None
assert u.allclose(wcs.wcs.aux.hglt_obs, 4.7711570596394015)
assert u.allclose(wcs.wcs.aux.dsun_obs, 148644585949.4918)
assert u.allclose(wcs.wcs.aux.crln_obs, 326.05139910339886)
observer = observer.transform_to(Heliocentric(observer=observer))
with pytest.raises(ValueError, match='obs_coord must be in a Stonyhurst or Carrington frame'):
_set_wcs_aux_obs_coord(wcs, observer)
def test_hpc_frame_to_wcs():
frame = Helioprojective(obstime='2013-10-28')
result_wcs = solar_frame_to_wcs_mapping(frame)
assert isinstance(result_wcs, WCS)
assert result_wcs.wcs.ctype[0] == 'HPLN-TAN'
assert result_wcs.wcs.cunit[0] == 'arcsec'
assert result_wcs.wcs.dateobs == '2013-10-28T00:00:00.000'
assert isinstance(result_wcs.heliographic_observer, HeliographicStonyhurst)
assert result_wcs.rsun == frame.rsun
def test_angular_radius_no_obstime():
coord = Helioprojective(0 * u.deg,
0 * u.deg,
5 * u.km,
obstime=None,
observer="earth")
with pytest.raises(
ValueError,
match=r"The observer must be fully defined by specifying `obstime`."
):
coord.angular_radius
def test_hpc_distance():
hpc1 = Helioprojective(0 * u.deg, 0 * u.arcsec,
observer=HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
assert isinstance(hpc1, Helioprojective)
# Check that we have a 2D wrap180 representation
assert isinstance(hpc1._data, UnitSphericalRepresentation)
# Check the attrs are correct
assert hpc1.Tx == 0 * u.arcsec
assert hpc1.Ty == 0 * u.arcsec
hpc2 = hpc1.make_3d()
assert isinstance(hpc2._data, SphericalRepresentation)
# Check the attrs are correct
assert hpc2.Tx == 0 * u.arcsec
assert hpc2.Ty == 0 * u.arcsec
assert_quantity_allclose(hpc2.distance, DSUN_METERS - RSUN_METERS)
def __init__(self,
bottom_left,
*,
top_right=None,
width: u.deg = None,
height: u.deg = None,
search="containing"):
bottom_left, top_right = get_rectangle_coordinates(bottom_left,
top_right=top_right,
width=width,
height=height)
bottom_left = bottom_left.transform_to(
Helioprojective(observer="earth"))
top_right = top_right.transform_to(Helioprojective(observer="earth"))
self.hpc_bounding_box_arcsec = ((bottom_left.Tx.to_value(u.arcsec),
bottom_left.Ty.to_value(u.arcsec)),
(top_right.Tx.to_value(u.arcsec),
top_right.Ty.to_value(u.arcsec)))
self.search_type = search
def test_hpc_default_observer():
# Observer is considered default if it hasn't been specified *and* if obstime isn't specified
hpc = Helioprojective(0*u.arcsec, 0*u.arcsec)
assert hpc.is_frame_attr_default('observer')
hpc = Helioprojective(0*u.arcsec, 0*u.arcsec, obstime='2019-06-01')
assert not hpc.is_frame_attr_default('observer')
def gwcs_3d():
detector_frame = cf.CoordinateFrame(
name="detector",
naxes=3,
axes_order=(0, 1, 2),
axes_type=("pixel", "pixel", "pixel"),
axes_names=("x", "y", "z"),
unit=(u.pix, u.pix, u.pix))
sky_frame = cf.CelestialFrame(reference_frame=Helioprojective(), name='hpc')
spec_frame = cf.SpectralFrame(name="spectral", axes_order=(2, ), unit=u.nm)
out_frame = cf.CompositeFrame(frames=(sky_frame, spec_frame))
return WCS(forward_transform=spatial_like_model(),
input_frame=detector_frame, output_frame=out_frame)
def identity_gwcs():
"""
A simple 1-1 gwcs that converts from pixels to arcseconds
"""
identity = m.Multiply(1 * u.arcsec / u.pixel) & m.Multiply(
1 * u.arcsec / u.pixel)
sky_frame = cf.CelestialFrame(
axes_order=(0, 1),
name='helioprojective',
reference_frame=Helioprojective(obstime="2018-01-01"))
detector_frame = cf.CoordinateFrame(name="detector",
naxes=2,
axes_order=(0, 1),
axes_type=("pixel", "pixel"),
axes_names=("x", "y"),
unit=(u.pix, u.pix))
return gwcs.wcs.WCS(forward_transform=identity,
output_frame=sky_frame,
input_frame=detector_frame)
def total_coordinates(self):
"""
Helioprojective coordinates for all loops for the instrument observer
"""
if not hasattr(self, 'counts_file'):
raise AttributeError(
f'''No counts file found for {self.name}. Build it first
using Observer.build_detector_files''')
with h5py.File(self.counts_file, 'r') as hf:
total_coordinates = u.Quantity(hf['coordinates'],
hf['coordinates'].attrs['units'])
coords = SkyCoord(x=total_coordinates[:, 0],
y=total_coordinates[:, 1],
z=total_coordinates[:, 2],
frame=HeliographicStonyhurst,
representation='cartesian')
# This extra transform-to is due to a bug where to convert out of an HEEQ frame
# one must first transform to a polar HGS frame
# FIXME: once this is fixed upstream in SunPy, this can be removed
return coords.transform_to(HeliographicStonyhurst).transform_to(
Helioprojective(observer=self.observer_coordinate))
def identity_gwcs_4d():
"""
A simple 1-1 gwcs that converts from pixels to arcseconds
"""
identity = (TwoDScale(1 * u.arcsec / u.pixel)
& m.Multiply(1 * u.nm / u.pixel)
& m.Multiply(1 * u.s / u.pixel))
sky_frame = cf.CelestialFrame(
axes_order=(0, 1),
name='helioprojective',
reference_frame=Helioprojective(obstime="2018-01-01"),
unit=(u.arcsec, u.arcsec),
axis_physical_types=("custom:pos.helioprojective.lon",
"custom:pos.helioprojective.lat"))
wave_frame = cf.SpectralFrame(axes_order=(2, ), unit=u.nm)
time_frame = cf.TemporalFrame(Time("2020-01-01T00:00",
format="isot",
scale="utc"),
axes_order=(3, ),
unit=u.s)
frame = cf.CompositeFrame([sky_frame, wave_frame, time_frame])
detector_frame = cf.CoordinateFrame(name="detector",
naxes=4,
axes_order=(0, 1, 2, 3),
axes_type=("pixel", "pixel", "pixel",
"pixel"),
axes_names=("x", "y", "z", "s"),
unit=(u.pix, u.pix, u.pix, u.pix))
wcs = gwcs.wcs.WCS(forward_transform=identity,
output_frame=frame,
input_frame=detector_frame)
wcs.pixel_shape = (10, 20, 30, 40)
wcs.array_shape = wcs.pixel_shape[::-1]
return wcs
def test_wrapping_off():
hpc1 = Helioprojective(359.9*u.deg, 10*u.deg, wrap_longitude=False)
assert_quantity_allclose(hpc1.Tx, 359.9*u.deg)
assert_quantity_allclose(hpc1.Tx.wrap_angle, 360*u.deg)
def test_on_frame_error():
with pytest.raises(ValueError):
Helioprojective(obstime='ajshdasjdhk')
def test_on_frame_error2():
with pytest.raises(ValueError):
Helioprojective(obstime=17263871263)
def projected_frame(self):
return Helioprojective(observer=self.observer,
obstime=self.observer.obstime)