def test_apply_shifts(aia171_test_map):
# take two copies of the AIA image and create a test mapcube.
mc = map.Map([aia171_test_map, aia171_test_map], cube=True)
# Pixel displacements have the y-displacement as the first entry
numerical_displacements = {"x": np.asarray([0.0, -2.7]), "y": np.asarray([0.0, -10.4])}
astropy_displacements = {"x": numerical_displacements["x"] * u.pix,
"y": numerical_displacements["y"] * u.pix}
# Test to see if the code can detect the fact that the input shifts are not
# astropy quantities
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], astropy_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, astropy_displacements["y"], numerical_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], numerical_displacements["x"])
# Test returning with no extra options - the code returns a mapcube only
test_output = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
assert(isinstance(test_output, map.MapCube))
# Test returning with no clipping. Output layers should have the same size
# as the original input layer.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False)
assert(test_mc[0].data.shape == aia171_test_map.data.shape)
assert(test_mc[1].data.shape == aia171_test_map.data.shape)
# Test returning with clipping. Output layers should be smaller than the
# original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=True)
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
# Test returning with default clipping. The default clipping is set to
# true, that is the mapcube is clipped. Output layers should be smaller
# than the original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
# Test that keywords are correctly passed
# Test for an individual keyword
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False,
cval=np.nan)
assert(np.all(np.logical_not(np.isfinite(test_mc[1].data[:, -1]))))
# Test for a combination of keywords, and that changing the interpolation
# order and how the edges are treated changes the results.
test_mc1 = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False,
order=2, mode='reflect')
test_mc2 = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False)
assert(np.all(test_mc1[1].data[:, -1] != test_mc2[1].data[:, -1]))
def test_apply_shifts(aia171_test_map):
# take two copies of the AIA image and create a test mapcube.
mc = map.Map([aia171_test_map, aia171_test_map], cube=True)
# Pixel displacements have the y-displacement as the first entry
numerical_displacements = {"x": np.asarray([0.0, -2.7]), "y": np.asarray([0.0, -10.4])}
astropy_displacements = {"x": numerical_displacements["x"] * u.pix,
"y": numerical_displacements["y"] * u.pix}
# Test to see if the code can detect the fact that the input shifts are not
# astropy quantities
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], astropy_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, astropy_displacements["y"], numerical_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], numerical_displacements["x"])
# Test returning with no extra options - the code returns a mapcube only
test_output = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
assert(isinstance(test_output, map.MapCube))
# Test returning with no clipping. Output layers should have the same size
# as the original input layer.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False)
assert(test_mc[0].data.shape == aia171_test_map.data.shape)
assert(test_mc[1].data.shape == aia171_test_map.data.shape)
# Test returning with clipping. Output layers should be smaller than the
# original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=True)
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
# Test returning with default clipping. The default clipping is set to
# true, that is the mapcube is clipped. Output layers should be smaller
# than the original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
# Test that keywords are correctly passed
# Test for an individual keyword
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False,
cval=np.nan)
assert(np.all(np.logical_not(np.isfinite(test_mc[1].data[:, -1]))))
# Test for a combination of keywords, and that changing the interpolation
# order and how the edges are treated changes the results.
test_mc1 = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False,
order=2, mode='reflect')
test_mc2 = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False)
assert(np.all(test_mc1[1].data[:, -1] != test_mc2[1].data[:, -1]))
def test_apply_shifts(aia171_test_map):
# take two copies of the AIA image and create a test mapcube.
mc = map.Map([aia171_test_map, aia171_test_map], cube=True)
# Pixel displacements have the y-displacement as the first entry
numerical_displacements = {"x": np.asarray([0.0, -2.7]), "y": np.asarray([0.0, -10.4])}
astropy_displacements = {"x": numerical_displacements["x"] * u.pix,
"y": numerical_displacements["y"] * u.pix}
# Test to see if the code can detect the fact that the input shifts are not
# astropy quantities
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], astropy_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, astropy_displacements["y"], numerical_displacements["x"])
with pytest.raises(TypeError):
tested = apply_shifts(mc, numerical_displacements["y"], numerical_displacements["x"])
# Test returning with no extra options - the code returns a mapcube only
test_output = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
assert(isinstance(test_output, map.MapCube))
# Test returning with no clipping. Output layers should have the same size
# as the original input layer.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=False)
assert(test_mc[0].data.shape == aia171_test_map.data.shape)
assert(test_mc[1].data.shape == aia171_test_map.data.shape)
# Test returning with clipping. Output layers should be smaller than the
# original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"], clip=True)
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
# Test returning with default clipping. The default clipping is set to
# true, that is the mapcube is clipped. Output layers should be smaller
# than the original layer by a known amount.
test_mc = apply_shifts(mc, astropy_displacements["y"], astropy_displacements["x"])
for i in range(0, len(test_mc.maps)):
clipped = calculate_clipping(astropy_displacements["y"], astropy_displacements["x"])
assert(test_mc[i].data.shape[0] == mc[i].data.shape[0] - np.max(clipped[0].value))
assert(test_mc[i].data.shape[1] == mc[i].data.shape[1] - np.max(clipped[1].value))
def mapcube_solar_derotate(mc, layer_index=0, clip=True, shift=None, **kwargs):
"""
Move the layers in a mapcube according to the input shifts.
If an input shift is not given, the shifts due to
solar rotation relative to an index layer is calculated and
applied. When using this functionality, it is a good idea to check
that the shifts that were applied to were reasonable and expected.
One way of checking this is to animate the original mapcube, animate
the derotated mapcube, and compare the differences you see to the
calculated shifts.
Parameters
----------
mc : `sunpy.map.MapCube`
A mapcube of shape (ny, nx, nt), where nt is the number of layers in
the mapcube.
layer_index : int
Solar derotation shifts of all maps in the mapcube are assumed
to be relative to the layer in the mapcube indexed by layer_index.
clip : bool
If True, then clip off x, y edges in the datacube that are potentially
affected by edges effects.
``**kwargs``
These keywords are passed to the function
`sunpy.physics.transforms.solar_rotation.calculate_solar_rotate_shift`.
Returns
-------
output : `sunpy.map.MapCube`
The results of the shifts applied to the input mapcube.
Examples
--------
>>> from sunpy.physics.transforms.solar_rotation import mapcube_solar_derotate
>>> import sunpy.data.sample
>>> map1 = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE)
>>> map2 = sunpy.map.Map(sunpy.data.sample.EIT_195_IMAGE)
>>> mc = sunpy.map.Map([map1, map2], cube=True)
>>> derotated_mc = mapcube_solar_derotate(mc)
>>> derotated_mc = mapcube_solar_derotate(mc, layer_index=-1)
>>> derotated_mc = mapcube_solar_derotate(mc, clip=False)
"""
# Size of the data
nt = len(mc.maps)
# Storage for the pixel shifts and the shifts in arcseconds
xshift_keep = np.zeros((nt)) * u.pix
yshift_keep = np.zeros_like(xshift_keep)
# If no shifts are passed in, calculate them. Otherwise,
# use the shifts passed in.
if shift is None:
shift = calculate_solar_rotate_shift(mc, layer_index=layer_index, **kwargs)
xshift_arcseconds = shift['x']
yshift_arcseconds = shift['y']
# Calculate the pixel shifts
for i, m in enumerate(mc):
xshift_keep[i] = xshift_arcseconds[i] / m.scale.x
yshift_keep[i] = yshift_arcseconds[i] / m.scale.y
# Apply the pixel shifts and return the mapcube
return apply_shifts(mc, yshift_keep, xshift_keep, clip=clip)
