def test_conv_hcc_hg(b0, l0):
coord = [28748691, 22998953]
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=b0, l0_deg=l0)
known_answer = [2.3744334, -4.9292855]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
# Make sure that r value is returned if radius=True
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=b0,
l0_deg=l0, radius=True)
known_answer = [2.3744334, -4.9292855, sun.constants.radius.si.value]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
def test_conv_hcc_hg():
coord = [13.0, 58.0]
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=img.heliographic_latitude, l0_deg=img.heliographic_longitude)
known_answer = [1.0791282e-06, -7.0640732]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
# Make sure that r value is returned if radius=True
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=img.heliographic_latitude,
l0_deg=img.heliographic_longitude, radius=True)
known_answer = [1.0791282e-06, -7.0640732, sun.constants.radius.si.value]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
def test_conv_hcc_hg(b0, l0):
coord = [28748691, 22998953]
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=b0, l0_deg=l0)
known_answer = [2.3744334, -4.9292855]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
# Make sure that r value is returned if radius=True
result = wcs.convert_hcc_hg(coord[0],
coord[1],
b0_deg=b0,
l0_deg=l0,
radius=True)
known_answer = [2.3744334, -4.9292855, sun.constants.radius.si.value]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
def test_conv_hcc_hg():
coord = [13.0, 58.0]
result = wcs.convert_hcc_hg(coord[0],
coord[1],
b0_deg=img.heliographic_latitude,
l0_deg=img.heliographic_longitude)
known_answer = [1.0791282e-06, -7.0640732]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
def test_conv_hcc_hg():
coord = [13.0, 58.0]
result = wcs.convert_hcc_hg(img.rsun_meters,
img.heliographic_latitude, img.heliographic_longitude,
coord[0], coord[1])
known_answer = [1.0791282e-06, -7.0640732]
magnitude = np.floor(np.log10(np.abs(known_answer)))
assert_array_almost_equal(result*10**(-magnitude),
known_answer*10**(-magnitude), decimal=2)
def test_convert_back():
# Make sure transformation followed by inverse transformation returns
# the original coordinates
coord = [40.0, 32.0]
assert_allclose(wcs.convert_hcc_hpc(*wcs.convert_hpc_hcc(*coord)),
coord, rtol=1e-2, atol=0)
coord = [13.0, 58.0]
assert_allclose(wcs.convert_hg_hcc(*wcs.convert_hcc_hg(*coord)),
coord, rtol=1e-2, atol=0)
coord = [34.0, 45.0]
assert_allclose(wcs.convert_hpc_hg(*wcs.convert_hg_hpc(*coord)),
coord, rtol=1e-2, atol=0)
def test_convert_to_coord(dsun, angle_unit, b0, l0):
x, y = (34.0, 96.0)
b0_deg = b0
l0_deg = l0
def check_conversion(from_coord, to_coord, expected):
# Make sure that wcs.convert_to_coord returns the expected value
assert_allclose(wcs.convert_to_coord(x,
y,
from_coord,
to_coord,
b0_deg=b0_deg,
l0_deg=l0_deg,
dsun_meters=dsun,
angle_units=angle_unit),
expected,
rtol=1e-2,
atol=0)
check_conversion('hcc', 'hg',
wcs.convert_hcc_hg(x, y, b0_deg=b0_deg, l0_deg=l0_deg))
check_conversion(
'hpc', 'hg',
wcs.convert_hpc_hg(x,
y,
b0_deg=b0_deg,
l0_deg=l0_deg,
dsun_meters=dsun,
angle_units=angle_unit))
check_conversion('hg', 'hcc',
wcs.convert_hg_hcc(x, y, b0_deg=b0_deg, l0_deg=l0_deg))
check_conversion(
'hcc', 'hpc',
wcs.convert_hcc_hpc(x, y, dsun_meters=dsun, angle_units=angle_unit))
check_conversion(
'hg', 'hpc',
wcs.convert_hg_hpc(x,
y,
b0_deg=b0_deg,
l0_deg=l0_deg,
dsun_meters=dsun,
angle_units=angle_unit))
check_conversion(
'hpc', 'hcc',
wcs.convert_hpc_hcc(x, y, dsun_meters=dsun, angle_units=angle_unit))
def test_convert_to_coord():
x, y = (34.0, 96.0)
b0_deg = img.heliographic_latitude
l0_deg = img.heliographic_longitude
units = img.units['x']
dsun=img.dsun
def check_conversion(from_coord, to_coord, expected):
# Make sure that wcs.convert_to_coord returns the expected value
assert_allclose(wcs.convert_to_coord(x, y, from_coord, to_coord,
b0_deg=b0_deg, l0_deg=l0_deg, dsun_meters=dsun, angle_units=units),
expected, rtol=1e-2, atol=0)
check_conversion('hcc', 'hg', wcs.convert_hcc_hg(x, y, b0_deg=b0_deg,
l0_deg=l0_deg))
check_conversion('hpc', 'hg', wcs.convert_hpc_hg(x, y, b0_deg=b0_deg,
l0_deg=l0_deg, dsun_meters=dsun, angle_units=units))
check_conversion('hg', 'hcc', wcs.convert_hg_hcc(x, y, b0_deg=b0_deg,
l0_deg=l0_deg))
check_conversion('hcc', 'hpc', wcs.convert_hcc_hpc(x, y, dsun_meters=dsun,
angle_units=units))
check_conversion('hg', 'hpc', wcs.convert_hg_hpc(x, y, b0_deg=b0_deg,
l0_deg=l0_deg, dsun_meters=dsun, angle_units=units))
check_conversion('hpc', 'hcc', wcs.convert_hpc_hcc(x, y, dsun_meters=dsun,
angle_units=units))
def test_convert_to_coord(dsun, angle_unit, b0, l0):
x, y = (34.0, 96.0)
b0_deg = b0
l0_deg = l0
def check_conversion(from_coord, to_coord, expected):
# Make sure that wcs.convert_to_coord returns the expected value
assert_allclose(wcs.convert_to_coord(x, y, from_coord, to_coord,
b0_deg=b0_deg, l0_deg=l0_deg, dsun_meters=dsun, angle_units=angle_unit),
expected, rtol=1e-2, atol=0)
check_conversion('hcc', 'hg', wcs.convert_hcc_hg(x, y, b0_deg=b0_deg,
l0_deg=l0_deg))
check_conversion('hpc', 'hg', wcs.convert_hpc_hg(x, y, b0_deg=b0_deg,
l0_deg=l0_deg, dsun_meters=dsun, angle_units=angle_unit))
check_conversion('hg', 'hcc', wcs.convert_hg_hcc(x, y, b0_deg=b0_deg,
l0_deg=l0_deg))
check_conversion('hcc', 'hpc', wcs.convert_hcc_hpc(x, y, dsun_meters=dsun,
angle_units=angle_unit))
check_conversion('hg', 'hpc', wcs.convert_hg_hpc(x, y, b0_deg=b0_deg,
l0_deg=l0_deg, dsun_meters=dsun, angle_units=angle_unit))
check_conversion('hpc', 'hcc', wcs.convert_hpc_hcc(x, y, dsun_meters=dsun,
angle_units=angle_unit))
def map_hpc_to_hg_rotate(m,
epi_lon=0*u.degree, epi_lat=90*u.degree,
lon_bin=1*u.degree, lat_bin=1*u.degree,
lon_num=None, lat_num=None, **kwargs):
"""
Transform raw data in HPC coordinates to HG' coordinates
HG' = HG, except center at wave epicenter
"""
x, y = wcs.convert_pixel_to_data([m.data.shape[1], m.data.shape[0]],
[m.scale.x.value, m.scale.y.value],
[m.reference_pixel.x.value, m.reference_pixel.y.value],
[m.reference_coordinate.x.value, m.reference_coordinate.y.value])
hccx, hccy, hccz = wcs.convert_hpc_hcc(x,
y,
angle_units=m.spatial_units.x,
dsun_meters=m.dsun.to('meter').value,
z=True)
rot_hccz, rot_hccx, rot_hccy = euler_zyz((hccz,
hccx,
hccy),
(0.,
epi_lat.to('degree').value-90.,
-epi_lon.to('degree').value))
lon_map, lat_map = wcs.convert_hcc_hg(rot_hccx,
rot_hccy,
b0_deg=m.heliographic_latitude.to('degree').value,
l0_deg=m.heliographic_longitude.to('degree').value,
z=rot_hccz)
lon_range = (np.nanmin(lon_map), np.nanmax(lon_map))
lat_range = (np.nanmin(lat_map), np.nanmax(lat_map))
# This method results in a set of lons and lats that in general does not
# exactly span the range of the data.
# lon = np.arange(lon_range[0], lon_range[1], lon_bin)
# lat = np.arange(lat_range[0], lat_range[1], lat_bin)
# This method gives a set of lons and lats that exactly spans the range of
# the data at the expense of having to define values of cdelt1 and cdelt2
if lon_num is None:
cdelt1 = lon_bin.to('degree').value
lon = np.arange(lon_range[0], lon_range[1], cdelt1)
else:
nlon = lon_num.to('pixel').value
cdelt1 = (lon_range[1] - lon_range[0]) / (1.0*nlon - 1.0)
lon = np.linspace(lon_range[0], lon_range[1], num=nlon)
if lat_num is None:
cdelt2 = lat_bin.to('degree').value
lat = np.arange(lat_range[0], lat_range[1], cdelt2)
else:
nlat = lat_num.to('pixel').value
cdelt2 = (lat_range[1] - lat_range[0]) / (1.0*nlat - 1.0)
lat = np.linspace(lat_range[0], lat_range[1], num=nlat)
# Create the grid
x_grid, y_grid = np.meshgrid(lon, lat)
ng_xyz = wcs.convert_hg_hcc(x_grid,
y_grid,
b0_deg=m.heliographic_latitude.to('degree').value,
l0_deg=m.heliographic_longitude.to('degree').value,
z=True)
ng_zp, ng_xp, ng_yp = euler_zyz((ng_xyz[2],
ng_xyz[0],
ng_xyz[1]),
(epi_lon.to('degree').value,
90.-epi_lat.to('degree').value,
0.))
# The function ravel flattens the data into a 1D array
points = np.vstack((lon_map.ravel(), lat_map.ravel())).T
values = np.array(m.data).ravel()
# Get rid of all of the bad (nan) indices (i.e. those off of the sun)
index = np.isfinite(points[:, 0]) * np.isfinite(points[:, 1])
# points = np.vstack((points[index,0], points[index,1])).T
points = points[index]
values = values[index]
newdata = griddata(points, values, (x_grid, y_grid), **kwargs)
newdata[ng_zp < 0] = np.nan
dict_header = {
'CDELT1': cdelt1,
'NAXIS1': len(lon),
'CRVAL1': lon.min(),
'CRPIX1': crpix12_value_for_HG,
'CRPIX2': crpix12_value_for_HG,
'CUNIT1': "deg",
'CTYPE1': "HG",
'CDELT2': cdelt2,
'NAXIS2': len(lat),
'CRVAL2': lat.min(),
'CUNIT2': "deg",
'CTYPE2': "HG",
'DATE_OBS': m.meta['date-obs'],
'DSUN_OBS': m.dsun.to('m').value,
"CRLN_OBS": m.carrington_longitude.to('degree').value,
"HGLT_OBS": m.heliographic_latitude.to('degree').value,
"HGLN_OBS": m.heliographic_longitude.to('degree').value,
'EXPTIME': m.exposure_time.to('s').value
}
# Find out where the non-finites are
mask = np.logical_not(np.isfinite(newdata))
# Return a masked array is appropriate
if mask is None:
hg = Map(newdata, MapMeta(dict_header))
else:
hg = Map(ma.array(newdata, mask=mask), MapMeta(dict_header))
hg.plot_settings = m.plot_settings
return hg
def map_hpc_to_hg_rotate(map, epi_lon = 0, epi_lat = 90, lon_bin = 1, lat_bin = 1):
"""
Transform raw data in HPC coordinates to HG' coordinates
HG' = HG, except center at wave epicenter
"""
x, y = sunpy.wcs.convert_pixel_to_data([map.shape[1], map.shape[0]],
[map.scale['x'], map.scale['y']],
[map.reference_pixel['x'], map.reference_pixel['y']],
[map.reference_coordinate['x'],map.reference_coordinate['y']])
hccx, hccy, hccz = wcs.convert_hpc_hcc(x, y, angle_units=map.units['x'], z=True)
rot_hccz, rot_hccx, rot_hccy = euler_zyz((hccz, hccx, hccy), (0., epi_lat-90., -epi_lon))
lon_map, lat_map = wcs.convert_hcc_hg(rot_hccx, rot_hccy, b0_deg=map.heliographic_latitude,
l0_deg=map.heliographic_longitude,z = rot_hccz)
lon_range = (np.nanmin(lon_map), np.nanmax(lon_map))
lat_range = (np.nanmin(lat_map), np.nanmax(lat_map))
lon = np.arange(lon_range[0], lon_range[1], lon_bin)
lat = np.arange(lat_range[0], lat_range[1], lat_bin)
x_grid, y_grid = np.meshgrid(lon, lat)
ng_xyz = wcs.convert_hg_hcc(x_grid, y_grid,b0_deg=map.heliographic_latitude,
l0_deg=map.heliographic_longitude,z=True)
ng_zp, ng_xp, ng_yp = euler_zyz((ng_xyz[2], ng_xyz[0], ng_xyz[1]),
(epi_lon, 90.-epi_lat, 0.))
#ravel flattens the data into a 1D array
points = np.vstack((lon_map.ravel(), lat_map.ravel())).T
values = np.array(map).ravel()
# get rid of all of the bad (nan) indices (i.e. those off of the sun)
index = np.isfinite(points[:,0]) * np.isfinite(points[:,1])
#points = np.vstack((points[index,0], points[index,1])).T
points = points[index]
values = values[index]
newdata = griddata(points, values, (x_grid,y_grid), method="linear")
newdata[ng_zp < 0] = np.nan
dict_header = {
'CDELT1': lon_bin,
'NAXIS1': len(lon),
'CRVAL1': lon.min(),
'CRPIX1': 1,
'CRPIX2': 1,
'CUNIT1': "deg",
'CTYPE1': "HG",
'CDELT2': lat_bin,
'NAXIS2': len(lat),
'CRVAL2': lat.min(),
'CUNIT2': "deg",
'CTYPE2': "HG",
'DATE_OBS': map.meta['date-obs']
}
header = dict_header
transformed_map = sunpy.map.Map(newdata, header)
transformed_map.name = map.name
return transformed_map
def map_hpc_to_hg_rotate(map, epi_lon=0, epi_lat=90, lon_bin=1, lat_bin=1):
"""
Transform raw data in HPC coordinates to HG' coordinates
HG' = HG, except center at wave epicenter
"""
x, y = sunpy.wcs.convert_pixel_to_data(
[map.shape[1], map.shape[0]], [map.scale['x'], map.scale['y']],
[map.reference_pixel['x'], map.reference_pixel['y']],
[map.reference_coordinate['x'], map.reference_coordinate['y']])
hccx, hccy, hccz = wcs.convert_hpc_hcc(x,
y,
angle_units=map.units['x'],
z=True)
rot_hccz, rot_hccx, rot_hccy = euler_zyz((hccz, hccx, hccy),
(0., epi_lat - 90., -epi_lon))
lon_map, lat_map = wcs.convert_hcc_hg(rot_hccx,
rot_hccy,
b0_deg=map.heliographic_latitude,
l0_deg=map.heliographic_longitude,
z=rot_hccz)
lon_range = (np.nanmin(lon_map), np.nanmax(lon_map))
lat_range = (np.nanmin(lat_map), np.nanmax(lat_map))
lon = np.arange(lon_range[0], lon_range[1], lon_bin)
lat = np.arange(lat_range[0], lat_range[1], lat_bin)
x_grid, y_grid = np.meshgrid(lon, lat)
ng_xyz = wcs.convert_hg_hcc(x_grid,
y_grid,
b0_deg=map.heliographic_latitude,
l0_deg=map.heliographic_longitude,
z=True)
ng_zp, ng_xp, ng_yp = euler_zyz((ng_xyz[2], ng_xyz[0], ng_xyz[1]),
(epi_lon, 90. - epi_lat, 0.))
#ravel flattens the data into a 1D array
points = np.vstack((lon_map.ravel(), lat_map.ravel())).T
values = np.array(map).ravel()
# get rid of all of the bad (nan) indices (i.e. those off of the sun)
index = np.isfinite(points[:, 0]) * np.isfinite(points[:, 1])
#points = np.vstack((points[index,0], points[index,1])).T
points = points[index]
values = values[index]
newdata = griddata(points, values, (x_grid, y_grid), method="linear")
newdata[ng_zp < 0] = np.nan
dict_header = {
'CDELT1': lon_bin,
'NAXIS1': len(lon),
'CRVAL1': lon.min(),
'CRPIX1': 1,
'CRPIX2': 1,
'CUNIT1': "deg",
'CTYPE1': "HG",
'CDELT2': lat_bin,
'NAXIS2': len(lat),
'CRVAL2': lat.min(),
'CUNIT2': "deg",
'CTYPE2': "HG",
'DATE_OBS': map.meta['date-obs']
}
header = dict_header
transformed_map = sunpy.map.Map(newdata, header)
transformed_map.name = map.name
return transformed_map
def params(flare,**kwargs):
m2deg = 360./(2*3.1415926*6.96e8)
if flare["event_coordunit"] == "degrees":
flare_event_coord1 = flare['event_coord1']
flare_event_coord2 = flare['event_coord2']
elif flare["event_coordunit"] == "arcsec" or flare["event_coordunit"] == "arcseconds":
info = pb0r(flare["event_starttime"])
flare_coords = convert_hcc_hg(#info["sd"] / 60.0,
info["b0"], info["l0"],
(flare['event_coord1'] / 3600.0),
(flare['event_coord2'] / 3600.0))
flare_event_coord1 = flare_coords[0]
flare_event_coord2 = flare_coords[1]
""" Define the parameters we will use for the unraveling of the maps"""
params = {"epi_lat": flare_event_coord2, #30., #degrees, HG latitude of wave epicenter
"epi_lon": flare_event_coord1, #45., #degrees, HG longitude of wave epicenter
#HG grid, probably would only want to change the bin sizes
"lat_min": -90.,
"lat_max": 90.,
"lat_bin": 0.2,
"lon_min": -180.,
"lon_max": 180.,
"lon_bin": 5.,
# #HPC grid, probably would only want to change the bin sizes
"hpcx_min": -1025.,
"hpcx_max": 1023.,
"hpcx_bin": 2.,
"hpcy_min": -1025.,
"hpcy_max": 1023.,
"hpcy_bin": 2.,
"hglt_obs": 0,
"rotation": 360. / (27. * 86400.), #degrees/s, rigid solar rotation
}
#params = {
# "cadence": 12., #seconds
#
# "hglt_obs": 0., #degrees
# "rotation": 360./(27.*86400.), #degrees/s, rigid solar rotation
#
# #Wave parameters that are initial conditions
# "direction": 25., #degrees, measured CCW from HG +latitude
# "epi_lat": 30., #degrees, HG latitude of wave epicenter
# "epi_lon": 45., #degrees, HG longitude of wave epicenter
#
# #Wave parameters that can evolve over time
# #The first element is constant in time
# #The second element (if present) is linear in time
# #The third element (if present) is quadratic in time
# #Be very careful of non-physical behavior
# "width": [90., 1.5], #degrees, full angle in azimuth, centered at 'direction'
# "wave_thickness": [6.0e6*m2deg,6.0e4*m2deg], #degrees, sigma of Gaussian profile in longitudinal direction
# "wave_normalization": [1.], #integrated value of the 1D Gaussian profile
# "speed": [9.33e5*m2deg, -1.495e3*m2deg], #degrees/s, make sure that wave propagates all the way to lat_min for polynomial speed
#
# #Noise parameters
# "noise_type": "Poisson", #can be None, "Normal", or "Poisson"
# "noise_scale": 0.3,
# "noise_mean": 1.,
# "noise_sdev": 1.,
#
# "max_steps": 20,
#
# #HG grid, probably would only want to change the bin sizes
# "lat_min": -90.,
# "lat_max": 90.,
# "lat_bin": 0.2,
# "lon_min": -180.,
# "lon_max": 180.,
# "lon_bin": 5.,
#
# #HPC grid, probably would only want to change the bin sizes
# "hpcx_min": -1025.,
# "hpcx_max": 1023.,
# "hpcx_bin": 2.,
# "hpcy_min": -1025.,
# "hpcy_max": 1023.,
# "hpcy_bin": 2.
#}
return params
def test_conv_hcc_hg():
coord = [13.0, 58.0]
result = wcs.convert_hcc_hg(coord[0], coord[1], b0_deg=img.heliographic_latitude, l0_deg=img.heliographic_longitude)
known_answer = [1.0791282e-06, -7.0640732]
assert_allclose(result, known_answer, rtol=1e-2, atol=0)
def map_hpc_to_hg_rotate(smap, epi_lon = 0, epi_lat = 0, xbin = 1, ybin = 1):
"""Take a map (like an AIA map) and convert it from HPC to HG."""
#import sunpy
#import util
#from sunpy import wcs
#import numpy as np
#from scipy.interpolate import griddata
from sim.wave2d.wave2d import euler_zyz
#from matplotlib import colors
# epi_lon = -10
# epi_lat = 0
#aia = sunpy.Map(sunpy.AIA_171_IMAGE).resample([500,500])
# tmap = util.map_hpc_to_hg(aia)
# tmap.show()
#map = aia
#x, y = wcs.convert_pixel_to_data(map.header)
x, y = wcs.convert_pixel_to_data(smap.shape[1],
smap.shape[0],
smap.scale['x'],
smap.scale['y'],
smap.reference_pixel['x'],
smap.reference_pixel['y'],
smap.reference_coordinate['x'],
smap.reference_coordinate['y'],
smap.coordinate_system['x'])
#hccx, hccy, hccz = wcs.convert_hpc_hcc_xyz(map.header, x, y)
hccx, hccy, hccz = wcs.convert_hpc_hcc_xyz(smap.rsun_meters,
smap.dsun,
smap.units['x'],
smap.units['y'],
x,
y)
# rot_hccz, rot_hccy, rot_hccx = euler_zyz((hccz, hccx, hccy), (epi_lon, 90.-epi_lat, 0.))
rot_hccz, rot_hccx, rot_hccy = euler_zyz((hccz, hccx, hccy), (0., epi_lat-90., -epi_lon))
# zpp, xpp, ypp = euler_zyz(zxy_p, (0., hglt_obs, total_seconds*rotation))
#lon_map, lat_map = wcs.convert_hcc_hg(map.header, rot_hccx, rot_hccy, z = rot_hccz)
lon_map, lat_map = wcs.convert_hcc_hg(smap.rsun_meters,
smap.heliographic_latitude,
smap.carrington_longitude,
rot_hccx, rot_hccy, z = rot_hccz)
lon_bin = xbin
lat_bin = ybin
lon_range = (np.nanmin(lon_map), np.nanmax(lon_map))
lat_range = (np.nanmin(lat_map), np.nanmax(lat_map))
lon = np.arange(lon_range[0], lon_range[1], lon_bin)
lat = np.arange(lat_range[0], lat_range[1], lat_bin)
newgrid = np.meshgrid(lon, lat)
#This extra conversion and rotation back are needed to determine where to
#mask out points that can't have corresponding data
#ng_xyz = wcs.convert_hg_hcc_xyz(map.header, newgrid[0], newgrid[1])
ng_xyz = wcs.convert_hg_hcc_xyz(smap.rsun_meters,
smap.heliographic_latitude,
smap.carrington_longitude,
newgrid[0], newgrid[1])
ng_zp, ng_xp, ng_yp = euler_zyz((ng_xyz[2], ng_xyz[0], ng_xyz[1]),
(epi_lon, 90.-epi_lat, 0.))
points = np.vstack((lon_map.ravel(), lat_map.ravel())).T
values = np.array(smap).ravel()
# get rid of all of the bad (nan) indices (i.e. those off of the sun)
index = np.isfinite(points[:,0]) * np.isfinite(points[:,1])
#points = np.vstack((points[index,0], points[index,1])).T
points = points[index]
values = values[index]
newdata = griddata(points, values, newgrid, method="cubic")
newdata[ng_zp < 0] = np.nan
header = smap._original_header.copy()
header['CDELT1'] = lon_bin
header['NAXIS1'] = len(lon)
header['CRVAL1'] = lon.min()
header['CRPIX1'] = 1
header['CRPIX2'] = 1
header['CUNIT1'] = "deg"
header['CTYPE1'] = "HG"
header['CDELT2'] = lat_bin
header['NAXIS2'] = len(lat)
header['CRVAL2'] = lat.min()
header['CUNIT2'] = "deg"
header['CTYPE2'] = "HG"
transformed_map = sunpy.map.BaseMap(newdata, header)
transformed_map.cmap = smap.cmap
transformed_map.name = smap.name
transformed_map.date = smap.date
transformed_map.center['x'] = wcs.get_center(smap.shape[1], smap.scale['x'], smap.reference_coordinate['x'],smap.reference_pixel['x'])
transformed_map.center['y'] = wcs.get_center(smap.shape[0], smap.scale['y'], smap.reference_coordinate['y'],smap.reference_pixel['y'])
#transformed_map.show()
return transformed_map
def map_hpc_to_hg_rotate(map, epi_lon=0, epi_lat=0, xbin=1, ybin=1):
"""Take a map (like an AIA map) and convert it from HPC to HG."""
# epi_lon = 0
# epi_lat = 90
# xbin = 1
# ybin = 1
x, y = sunpy.wcs.convert_pixel_to_data(
map.shape[1],
map.shape[0],
map.scale["x"],
map.scale["y"],
map.reference_pixel["x"],
map.reference_pixel["y"],
map.reference_coordinate["x"],
map.reference_coordinate["y"],
map.coordinate_system["x"],
)
hccx, hccy, hccz = wcs.convert_hpc_hcc_xyz(map.rsun_meters, map.dsun, map.units["x"], map.units["y"], x, y)
rot_hccz, rot_hccx, rot_hccy = euler_zyz((hccz, hccx, hccy), (0.0, epi_lat - 90.0, -epi_lon))
lon_map, lat_map = wcs.convert_hcc_hg(
map.rsun_meters, map.heliographic_latitude, map.heliographic_longitude, rot_hccx, rot_hccy, z=rot_hccz
)
lon_bin = xbin
lat_bin = ybin
lon_range = (np.nanmin(lon_map), np.nanmax(lon_map))
lat_range = (np.nanmin(lat_map), np.nanmax(lat_map))
lon = np.arange(lon_range[0], lon_range[1], lon_bin)
lat = np.arange(lat_range[0], lat_range[1], lat_bin)
newgrid = np.meshgrid(lon, lat)
ng_xyz = wcs.convert_hg_hcc_xyz(
map.rsun_meters, map.heliographic_latitude, map.heliographic_longitude, newgrid[0], newgrid[1]
)
ng_zp, ng_xp, ng_yp = euler_zyz((ng_xyz[2], ng_xyz[0], ng_xyz[1]), (epi_lon, 90.0 - epi_lat, 0.0))
points = np.vstack((lon_map.ravel(), lat_map.ravel())).T
values = np.array(map).ravel()
# get rid of all of the bad (nan) indices (i.e. those off of the sun)
index = np.isfinite(points[:, 0]) * np.isfinite(points[:, 1])
# points = np.vstack((points[index,0], points[index,1])).T
points = points[index]
values = values[index]
newdata = griddata(points, values, newgrid, method="linear")
newdata[ng_zp < 0] = np.nan
dict_header = {
"CDELT1": lon_bin,
"NAXIS1": len(lon),
"CRVAL1": lon.min(),
"CRPIX1": 1,
"CRPIX2": 1,
"CUNIT1": "deg",
"CTYPE1": "HG",
"CDELT2": lat_bin,
"NAXIS2": len(lat),
"CRVAL2": lat.min(),
"CUNIT2": "deg",
"CTYPE2": "HG",
}
header = sunpy.map.MapHeader(dict_header)
transformed_map = sunpy.make_map(newdata, header)
return transformed_map
from sunpy.wcs import convert_hg_hcc, convert_hcc_hg from sunpy.coords import pb0r from sunpy.coords import rot_hcc dt = '2008-04-12' v = pb0r(dt) x = 200 y = 100 print '============' print 'Arcsecond location', x, y h1,h2 = convert_hcc_hg(v["sd"]/60.0, v["b0"], v["l0"], x/3600.0, y/3600.0) print 'Lat, lon', h1, h2 nx, ny = convert_hg_hcc(v["sd"]/60.0, v["b0"], v["l0"], h1, h2) print 'Roundtrip arcsec loc.', 3600*nx, 3600*ny #nx, ny = convert_hg_hcc(v["sd"]/60.0, v["b0"], v["l0"], h1, h2) #print nx*3600, ny*3600 nnx, nny = convert_hg_hcc(v["sd"]/60.0, v["b0"], v["l0"] , 10.931230, 48.717380) print nnx*3600, ny*3600 newx, newy = rot_hcc(x,y, tstart=dt, tend='2008-04-14') print newx, newy
