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(): 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 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