def pixel_to_data(self, x=None, y=None):
"""Convert from pixel coordinates to data coordinates (e.g. arcsec)"""
width = self.shape[1]
height = self.shape[0]
if (x is not None) & (x > width - 1):
raise ValueError("X pixel value larger than image width (%s)." %
width)
if (x is not None) & (y > height - 1):
raise ValueError("Y pixel value larger than image height (%s)." %
height)
if (x is not None) & (x < 0):
raise ValueError("X pixel value cannot be less than 0.")
if (x is not None) & (y < 0):
raise ValueError("Y pixel value cannot be less than 0.")
scale = np.array([self.scale['x'], self.scale['y']])
crpix = np.array(
[self.reference_pixel['x'], self.reference_pixel['y']])
crval = np.array(
[self.reference_coordinate['x'], self.reference_coordinate['y']])
coordinate_system = [
self.coordinate_system['x'], self.coordinate_system['y']
]
x, y = wcs.convert_pixel_to_data(self.shape,
scale,
crpix,
crval,
x=x,
y=y)
return x, y
def warp_sun(xy, data, deltatime):
x,y = xy.T
#Define some tuples
scale = [data.scale['x'], data.scale['y']]
ref_pix = [data.reference_pixel['x'], data.reference_pixel['y']]
ref_coord = [data.reference_coordinate['x'], data.reference_coordinate['y']]
#Calculate the hpc coords for all pixels
hpc_coords = wcs.convert_pixel_to_data(data.shape, scale,
ref_pix, ref_coord)
#Calculate the shift in hpc coords for all pixels
rotted = cu.rot_hpc(hpc_coords[1], hpc_coords[0], data.date,
parse_time(data.date)- deltatime)
#Translate back to pixel coords
x2,y2 = wcs.convert_data_to_pixel(rotted[0], rotted[1], scale, ref_pix,
ref_coord)
#Restack the data to make it correct output form
xy2 = np.column_stack([x2.flat,y2.flat])
#Remove NaNs
mask = np.isnan(xy2)
xy2[mask] = 0.0
return xy2
def pixel_to_data(self, x=None, y=None):
"""Convert from pixel coordinates to data coordinates (e.g. arcsec)"""
width = self.shape[1]
height = self.shape[0]
if (x is not None) & (x > width - 1):
raise ValueError(
"X pixel value larger than image width (%s)." % width)
if (x is not None) & (y > height - 1):
raise ValueError(
"Y pixel value larger than image height (%s)." % height)
if (x is not None) & (x < 0):
raise ValueError("X pixel value cannot be less than 0.")
if (x is not None) & (y < 0):
raise ValueError("Y pixel value cannot be less than 0.")
scale = np.array([self.scale['x'], self.scale['y']])
crpix = np.array(
[self.reference_pixel['x'], self.reference_pixel['y']])
crval = np.array(
[self.reference_coordinate['x'], self.reference_coordinate['y']])
coordinate_system = [
self.coordinate_system['x'], self.coordinate_system['y']
]
x, y = wcs.convert_pixel_to_data(
self.shape, scale, crpix, crval, x=x, y=y)
return x, y
def map_hg_to_hpc(smap, xbin = 10, ybin = 10):
"""Take a map in heliographic coordinates (HG) and convert it to
helioprojective cartesian coordinates (HPC)."""
lon,lat = wcs.convert_pixel_to_data(smap.header)
x_map, y_map = wcs.convert_hg_hpc(smap.header, lon, lat, units ='arcsec')
x_range = (np.nanmin(x_map), np.nanmax(x_map))
y_range = (np.nanmin(y_map), np.nanmax(y_map))
x = np.arange(x_range[0], x_range[1], xbin)
y = np.arange(y_range[0], y_range[1], ybin)
newgrid = np.meshgrid(x, y)
# newgrid = wcs.convert_hpc_hg(map.header, xgrid/(3600), ygrid/(3600))
points = np.vstack((x_map.ravel(), y_map.ravel())).T
values = np.array(smap).ravel()
newdata = griddata(points, values, newgrid, method="linear")
# now grab the original map header and update it
header = smap.header.copy()
header["CDELT1"] = xbin
header["NAXIS1"] = len(x)
header["CRVAL1"] = x.min()
header["CRPIX1"] = 1
header["CUNIT1"] = "arcsec"
header["CTYPE1"] = "HPLT-TAN"
header["CDELT2"] = ybin
header["NAXIS2"] = len(y)
header["CRVAL2"] = y.min()
header["CRPIX2"] = 1
header["CUNIT2"] = "arcsec"
header["CTYPE2"] = "HPLT-TAN"
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(header, axis='x'),
"y": wcs.get_center(header, axis='y')}
return transformed_map
def transform(params, wave_maps, verbose=False):
"""
Transform raw data in HG' coordinates to HPC coordinates
HG' = HG, except center at wave epicenter
"""
solar_rotation_rate = params["rotation"]
hglt_obs = params["hglt_obs"].to('degree').value
# crln_obs = params["crln_obs"]
epi_lat = params["epi_lat"].to('degree').value
epi_lon = params["epi_lon"].to('degree').value
# Parameters for the HPC co-ordinates
hpcx_min = params["hpcx_min"].to('arcsec').value
hpcx_max = params["hpcx_max"].to('arcsec').value
hpcx_bin = params["hpcx_bin"].to('arcsec').value
hpcy_min = params["hpcy_min"].to('arcsec').value
hpcy_max = params["hpcy_max"].to('arcsec').value
hpcy_bin = params["hpcy_bin"].to('arcsec').value
hpcx_num = int(round((hpcx_max-hpcx_min)/hpcx_bin))
hpcy_num = int(round((hpcy_max-hpcy_min)/hpcy_bin))
# Storage for the HPC version of the input maps
wave_maps_transformed = []
# The properties of this map are used in the transform
smap = wave_maps[0]
# Basic dictionary version of the HPC map header
dict_header = {
"CDELT1": hpcx_bin,
"NAXIS1": hpcx_num,
"CRVAL1": hpcx_min,
"CRPIX1": crpix12_value_for_HPC,
"CUNIT1": "arcsec",
"CTYPE1": "HPLN-TAN",
"CDELT2": hpcy_bin,
"NAXIS2": hpcy_num,
"CRVAL2": hpcy_min,
"CRPIX2": crpix12_value_for_HPC,
"CUNIT2": "arcsec",
"CTYPE2": "HPLT-TAN",
"HGLT_OBS": hglt_obs,
"CRLN_OBS": smap.carrington_longitude.to('degree').value,
"DSUN_OBS": sun.sunearth_distance(BASE_DATE.strftime(BASE_DATE_FORMAT)).to('meter').value,
"DATE_OBS": BASE_DATE.strftime(BASE_DATE_FORMAT),
"EXPTIME": 1.0
}
start_date = smap.date
# Origin grid, HG'
lon_grid, lat_grid = wcs.convert_pixel_to_data([smap.data.shape[1], smap.data.shape[0]],
[smap.scale.x.value, smap.scale.y.value],
[smap.reference_pixel.x.value, smap.reference_pixel.y.value],
[smap.reference_coordinate.x.value, smap.reference_coordinate.y.value])
# Origin grid, HG' to HCC'
# HCC' = HCC, except centered at wave epicenter
x, y, z = wcs.convert_hg_hcc(lon_grid, lat_grid,
b0_deg=smap.heliographic_latitude.to('degree').value,
l0_deg=smap.carrington_longitude.to('degree').value,
z=True)
# Origin grid, HCC' to HCC''
# Moves the wave epicenter to initial conditions
# HCC'' = HCC, except assuming that HGLT_OBS = 0
zxy_p = euler_zyz((z, x, y),
(epi_lon, 90.-epi_lat, 0.))
# Destination HPC grid
hpcx_grid, hpcy_grid = wcs.convert_pixel_to_data([dict_header['NAXIS1'], dict_header['NAXIS2']],
[dict_header['CDELT1'], dict_header['CDELT2']],
[dict_header['CRPIX1'], dict_header['CRPIX2']],
[dict_header['CRVAL1'], dict_header['CRVAL2']])
for icwm, current_wave_map in enumerate(wave_maps):
print(icwm, len(wave_maps))
# Elapsed time
td = parse_time(current_wave_map.date) - parse_time(start_date)
# Update the header
dict_header['DATE_OBS'] = current_wave_map.date
dict_header['DSUN_OBS'] = current_wave_map.dsun.to('m').value
# Origin grid, HCC'' to HCC
# Moves the observer to HGLT_OBS and adds rigid solar rotation
total_seconds = u.s * (td.microseconds + (td.seconds + td.days * 24.0 * 3600.0) * 10.0**6) / 10.0**6
solar_rotation = (total_seconds * solar_rotation_rate).to('degree').value
zpp, xpp, ypp = euler_zyz(zxy_p,
(0., hglt_obs, solar_rotation))
# Origin grid, HCC to HPC (arcsec)
xx, yy = wcs.convert_hcc_hpc(xpp, ypp,
dsun_meters=current_wave_map.dsun.to('m').value)
# Coordinate positions (HPC) with corresponding map data
points = np.vstack((xx.ravel(), yy.ravel())).T
values = np.asarray(deepcopy(current_wave_map.data)).ravel()
# Solar rotation can push the points off disk and into areas that have
# nans. if this is the case, then griddata fails
# Two solutions
# 1 - replace all the nans with zeros, in order to get the code to run
# 2 - the initial condition of zpp.ravel() >= 0 should be extended
# to make sure that only finite points are used.
# 2D interpolation from origin grid to destination grid
valid_points = np.logical_and(zpp.ravel() >= 0,
np.isfinite(points[:, 0]),
np.isfinite(points[:, 1]))
grid = griddata(points[valid_points],
values[valid_points],
(hpcx_grid, hpcy_grid),
method="linear")
transformed_wave_map = Map(grid, MapMeta(dict_header))
transformed_wave_map.plot_settings = deepcopy(current_wave_map.plot_settings)
# transformed_wave_map.name = current_wave_map.name
# transformed_wave_map.meta['date-obs'] = current_wave_map.date
wave_maps_transformed.append(transformed_wave_map)
return Map(wave_maps_transformed, cube=True)
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_hg_to_hpc_rotate(m,
epi_lon=90*u.degree, epi_lat=0*u.degree,
xbin=2.4*u.arcsec, ybin=2.4*u.arcsec,
xnum=None, ynum=None,
solar_information=None, **kwargs):
"""
Transform raw data in HG' coordinates to HPC coordinates
HG' = HG, except center at wave epicenter
"""
# Origin grid, HG'
lon_grid, lat_grid = 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])
# Origin grid, HG' to HCC'
# HCC' = HCC, except centered at wave epicenter
x, y, z = wcs.convert_hg_hcc(lon_grid, lat_grid,
b0_deg=m.heliographic_latitude.to('degree').value,
l0_deg=m.carrington_longitude.to('degree').value,
z=True)
# Origin grid, HCC' to HCC''
# Moves the wave epicenter to initial conditions
# HCC'' = HCC, except assuming that HGLT_OBS = 0
zpp, xpp, ypp = euler_zyz((z,
x,
y),
(epi_lon.to('degree').value,
90.-epi_lat.to('degree').value,
0.))
# Add in a solar rotation. Useful when creating simulated HPC data from
# HG data. This code was adapted from the wave simulation code of the
# AWARE project.
if solar_information is not None:
hglt_obs = solar_information['hglt_obs'].to('degree').value
solar_rotation_value = solar_information['angle_rotated'].to('degree').value
#print(hglt_obs, solar_rotation_value)
#print('before', zpp, xpp, ypp)
zpp, xpp, ypp = euler_zyz((zpp,
xpp,
ypp),
(0.,
hglt_obs,
solar_rotation_value))
#print('after', zpp, xpp, ypp)
# Origin grid, HCC to HPC (arcsec)
# xx, yy = wcs.convert_hcc_hpc(current_wave_map.header, xpp, ypp)
xx, yy = wcs.convert_hcc_hpc(xpp, ypp,
dsun_meters=m.dsun.to('meter').value)
# Destination HPC grid
hpcx_range = (np.nanmin(xx), np.nanmax(xx))
hpcy_range = (np.nanmin(yy), np.nanmax(yy))
if xnum is None:
cdelt1 = xbin.to('arcsec').value
hpcx = np.arange(hpcx_range[0], hpcx_range[1], cdelt1)
else:
nx = xnum.to('pixel').value
cdelt1 = (hpcx_range[1] - hpcx_range[0]) / (1.0*nx - 1.0)
hpcx = np.linspace(hpcx_range[1], hpcx_range[0], num=nx)
if ynum is None:
cdelt2 = ybin.to('arcsec').value
hpcy = np.arange(hpcy_range[0], hpcy_range[1], cdelt2)
else:
ny = ynum.to('pixel').value
cdelt2 = (hpcy_range[1] - hpcy_range[0]) / (1.0*ny - 1.0)
hpcy = np.linspace(hpcy_range[1], hpcy_range[0], num=ny)
# Calculate the grid mesh
newgrid_x, newgrid_y = np.meshgrid(hpcx, hpcy)
#
# CRVAL1,2 and CRPIX1,2 are calculated so that the co-ordinate system is
# at the center of the image
# Note that crpix[] counts pixels starting at 1
crpix1 = 1 + hpcx.size // 2
crval1 = hpcx[crpix1 - 1]
crpix2 = 1 + hpcy.size // 2
crval2 = hpcy[crpix2 - 1]
dict_header = {
"CDELT1": cdelt1,
"NAXIS1": len(hpcx),
"CRVAL1": crval1,
"CRPIX1": crpix1,
"CUNIT1": "arcsec",
"CTYPE1": "HPLN-TAN",
"CDELT2": cdelt2,
"NAXIS2": len(hpcy),
"CRVAL2": crval2,
"CRPIX2": crpix2,
"CUNIT2": "arcsec",
"CTYPE2": "HPLT-TAN",
"HGLT_OBS": m.heliographic_latitude.to('degree').value, # 0.0
# "HGLN_OBS": 0.0,
"CRLN_OBS": m.carrington_longitude.to('degree').value, # 0.0
'DATE_OBS': m.meta['date-obs'],
'DSUN_OBS': m.dsun.to('m').value,
'EXPTIME': m.exposure_time.to('s').value
}
# Coordinate positions (HPC) with corresponding map data
points = np.vstack((xx.ravel(), yy.ravel())).T
values = np.asarray(deepcopy(m.data)).ravel()
# Solar rotation can push the points off disk and into areas that have
# nans. if this is the case, then griddata fails
# Two solutions
# 1 - replace all the nans with zeros, in order to get the code to run
# 2 - the initial condition of zpp.ravel() >= 0 should be extended
# to make sure that only finite points are used.
# 2D interpolation from origin grid to destination grid
valid_points = np.logical_and(zpp.ravel() >= 0,
np.isfinite(points[:, 0]),
np.isfinite(points[:, 1]))
# 2D interpolation from origin grid to destination grid
grid = griddata(points[valid_points],
values[valid_points],
(newgrid_x, newgrid_y), **kwargs)
# Find out where the non-finites are
mask = np.logical_not(np.isfinite(grid))
# Return a masked array is appropriate
if mask is None:
hpc = Map(grid, MapMeta(dict_header))
else:
hpc = Map(ma.array(grid, mask=mask), MapMeta(dict_header))
hpc.plot_settings = m.plot_settings
return hpc
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(smap, xbin = 1, ybin = 1):
"""Take a map (like an AIA map) and convert it from HPC to HG."""
#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.center['x'],
smap.center['y'],
smap.reference_coordinate['x'],
smap.reference_coordinate['y'],
smap.coordinate_system['x'])
#lon_map, lat_map = wcs.convert_hpc_hg(map.header, x, y)
lon_map, lat_map = wcs.convert_hpc_hg(smap.rsun_meters,
smap.dsun,
smap.scale['x'],
smap.scale['y'],
smap.heliographic_latitude,
smap.carrington_longitude,
x, y)
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)
# newgrid = wcs.convert_hg_hpc(map.header, lon_grid, lat_grid, units = 'arcsec')
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
values = values[index]
newdata = griddata(points, values, newgrid, method="linear")
header = smap.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 = map.cmap
transformed_map.name = map.name
transformed_map.date = map.date
transformed_map.center = {
"x": wcs.get_center(header, axis='x'),
"y": wcs.get_center(header, axis='y')}
return transformed_map
ynum=transform_hg2hpc_parameters['ynum'])
hpc.peek(aspect='auto')
#
# copied from map_hg_to_hpc_rotate
#
xnum = transform_hg2hpc_parameters['xnum']
ynum = transform_hg2hpc_parameters['ynum']
epi_lon = transform_hg2hpc_parameters['epi_lon']
epi_lat = transform_hg2hpc_parameters['epi_lat']
# Origin grid, HG'
lon_grid, lat_grid = wcs.convert_pixel_to_data(
[hg.data.shape[1], hg.data.shape[0]],
[hg.scale.x.value, hg.scale.y.value],
[hg.reference_pixel.x.value, hg.reference_pixel.y.value],
[hg.reference_coordinate.x.value, hg.reference_coordinate.y.value])
# Origin grid, HG' to HCC'
# HCC' = HCC, except centered at wave epicenter
x, y, z = wcs.convert_hg_hcc(lon_grid, lat_grid,
b0_deg=hg.heliographic_latitude.to('degree').value,
l0_deg=hg.carrington_longitude.to('degree').value,
z=True)
# Origin grid, HCC' to HCC''
# Moves the wave epicenter to initial conditions
# HCC'' = HCC, except assuming that HGLT_OBS = 0
zpp, xpp, ypp = euler_zyz((z,
x,
