def _draw_catalog(self, catalog, catalog_kwargs, projection, ax):
"""
Overlay catalog on top of map.
Parameters
----------
catalog : :py:class:`~numpy.ndarray`
`catalog` parameter given to :py:meth:`draw`.
catalog_kwargs : dict
`catalog_kwargs` parameter given to :py:meth:`draw`.
projection : :py:class:`pyproj.Proj`
PyProj projection object.
ax : :py:class:`~matplotlib.axes.Axes`
Axes to plot on.
"""
if catalog is not None:
N_src = catalog.size // 3
if not (catalog.shape == (3, N_src)):
raise ValueError(
"Parameter[catalog]: expected (3, N_src) array.")
_, c_lat, c_lon = transform.cart2eq(*catalog)
c_x, c_y = self._eq2xy(c_lat, c_lon, projection)
if catalog_kwargs is None:
catalog_kwargs = dict()
plot_style = dict(s=400, facecolors="none", edgecolors="w")
plot_style.update(catalog_kwargs)
ax.scatter(c_x, c_y, **plot_style)
def _draw_projection(self, projection):
"""
Setup :py:class:`pyproj.Proj` object to do (lon,lat) <-> (x,y) transforms.
Parameters
----------
projection : str
`projection` parameter given to :py:meth:`draw`.
Returns
-------
proj : :py:class:`pyproj.Proj`
"""
# Most projections can be provided a point in space around which distortions are minimized.
# We choose this point to approximately map to the center of the grid when appropriate.
# (approximate since it is not always a spherical cap.)
if self._is_gridded: # (3, N_height, N_width) grid
grid_dir = np.mean(self._grid, axis=(1, 2))
else: # (3, N_points) grid
grid_dir = np.mean(self._grid, axis=1)
_, grid_lat, grid_lon = transform.cart2eq(*grid_dir)
grid_lat, grid_lon = self._wrapped_rad2deg(grid_lat, grid_lon)
p_name = projection.lower()
if p_name == "lcc":
# Lambert Conformal Conic
proj = pyproj.Proj(proj="lcc", lon_0=grid_lon, lat_0=grid_lat, R=1)
elif p_name == "aeqd":
# Azimuthal Equi-Distant
proj = pyproj.Proj(proj="aeqd",
lon_0=grid_lon,
lat_0=grid_lat,
R=1)
elif p_name == "laea":
# Lambert Equal-Area
proj = pyproj.Proj(proj="laea",
lon_0=grid_lon,
lat_0=grid_lat,
R=1)
elif p_name == "robin":
# Robinson
proj = pyproj.Proj(proj="robin", lon_0=grid_lon, R=1)
elif p_name == "gnom":
# Gnomonic
proj = pyproj.Proj(proj="gnom",
lon_0=grid_lon,
lat_0=grid_lat,
R=1)
elif p_name == "healpix":
# Hierarchical Equal-Area Pixelisation
proj = pyproj.Proj(proj="healpix",
lon_0=grid_lon,
lat_0=grid_lat,
R=1)
else:
raise ValueError(
"Parameter[projection] is not a valid projection specifier.")
return proj
if __name__ == '__main__':
args = parse_args()
D = [nn.DataSet.from_file(str(_)) for _ in args['datasets']]
P = [np.load(_) for _ in args['parameters']]
R = D[0].R
N_px = R.shape[1]
N_sample = len(args['img_idx'])
I_all = np.zeros((N_sample, 3, N_px))
for i, idx_img in tqdm.tqdm(list(enumerate(args['img_idx']))):
I = get_field(D, P, idx_img, img_type=args['img_type'])
I_rgb = to_RGB(I)
# I_rgb /= I_rgb.max()
# Filter field to lie in specified interval
_, R_lat, R_lon = transform.cart2eq(*R)
_, R_lon_d = wrapped_rad2deg(R_lat, R_lon)
min_lon, max_lon = args['lon_ticks'].min(), args['lon_ticks'].max()
mask_lon = (min_lon <= R_lon_d) & (R_lon_d <= max_lon)
R_field = transform.eq2cart(1, R_lat[mask_lon], R_lon[mask_lon])
I_rgb = I_rgb[:, mask_lon]
I_all[i] = I_rgb
np.savez(args['out'], I_rgb=I_all)
def draw_map(I,
R,
lon_ticks,
catalog=None,
show_labels=False,
show_axis=False):
"""
Parameters
==========
I : :py:class:`~numpy.ndarray`
(3, N_px)
R : :py:class:`~numpy.ndarray`
(3, N_px)
"""
import mpl_toolkits.basemap as basemap
import matplotlib.tri as tri
_, R_el, R_az = transform.cart2eq(*R)
R_el, R_az = wrapped_rad2deg(R_el, R_az)
R_el_min, R_el_max = np.around([np.min(R_el), np.max(R_el)])
R_az_min, R_az_max = np.around([np.min(R_az), np.max(R_az)])
fig = plt.figure()
ax = fig.add_subplot(111)
bm = basemap.Basemap(projection='mill',
llcrnrlat=R_el_min,
urcrnrlat=R_el_max,
llcrnrlon=R_az_min,
urcrnrlon=R_az_max,
resolution='c',
ax=ax)
if show_axis:
bm_labels = [1, 0, 0, 1]
else:
bm_labels = [0, 0, 0, 0]
bm.drawparallels(np.linspace(R_el_min, R_el_max, 5),
color='w',
dashes=[1, 0],
labels=bm_labels,
labelstyle='+/-',
textcolor='#565656',
zorder=0,
linewidth=2)
bm.drawmeridians(lon_ticks,
color='w',
dashes=[1, 0],
labels=bm_labels,
labelstyle='+/-',
textcolor='#565656',
zorder=0,
linewidth=2)
if show_labels:
ax.set_xlabel('Azimuth (degrees)', labelpad=20)
ax.set_ylabel('Elevation (degrees)', labelpad=40)
R_x, R_y = bm(R_az, R_el)
triangulation = tri.Triangulation(R_x, R_y)
N_px = I.shape[1]
mycmap = cmap_from_list('mycmap', I_rgb.T, N=N_px)
colors_cmap = np.arange(N_px)
ax.tripcolor(triangulation,
colors_cmap,
cmap=mycmap,
shading='gouraud',
alpha=0.9,
edgecolors='w',
linewidth=0.1)
if catalog is not None:
_, sky_el, sky_az = transform.cart2eq(*catalog.xyz)
sky_el, sky_az = wrapped_rad2deg(sky_el, sky_az)
sky_x, sky_y = bm(sky_az, sky_el)
ax.scatter(sky_x, sky_y, c='w', s=5)
return fig, ax
def _draw_gridlines(self, show_gridlines, grid_kwargs, projection, ax):
"""
Plot Right-Ascension / Declination lines.
Parameters
----------
show_gridlines : bool
`show_gridlines` parameter given to :py:meth:`draw`.
grid_kwargs : dict
`grid_kwargs` parameter given to :py:meth:`draw`.
projection : :py:class:`pyproj.Proj`
PyProj projection object.
ax : :py:class:`~matplotlib.axes.Axes`
Axes to plot on.
"""
if grid_kwargs is None:
grid_kwargs = dict()
if "N_parallel" in grid_kwargs:
N_parallel = grid_kwargs.pop("N_parallel")
if not (chk.is_integer(N_parallel) and (N_parallel >= 3)):
raise ValueError("Value[N_parallel] must be at least 3.")
else:
N_parallel = 3
if "N_meridian" in grid_kwargs:
N_meridian = grid_kwargs.pop("N_meridian")
if not (chk.is_integer(N_meridian) and (N_meridian >= 3)):
raise ValueError("Value[N_meridian] must be at least 3.")
else:
N_meridian = 3
if "polar_plot" in grid_kwargs:
polar_plot = grid_kwargs.pop("polar_plot")
if not chk.is_boolean(polar_plot):
raise ValueError("Value[polar_plot] must be boolean.")
else:
polar_plot = False
if "ticks" in grid_kwargs:
show_ticks = grid_kwargs.pop("ticks")
if not chk.is_boolean(show_ticks):
raise ValueError("Value[ticks] must be boolean.")
else:
# TODO: change to True once implemented.
show_ticks = False
plot_style = dict(alpha=0.5, color="k", linewidth=1, linestyle="solid")
plot_style.update(grid_kwargs)
_, grid_lat, grid_lon = transform.cart2eq(*self._grid)
grid_lat, grid_lon = self._wrapped_rad2deg(grid_lat, grid_lon)
# RA curves
meridian = dict()
dec_span = np.linspace(grid_lat.min(), grid_lat.max(), 200)
if polar_plot:
ra = np.linspace(-180, 180, N_meridian, endpoint=False)
else:
ra = np.linspace(grid_lon.min(), grid_lon.max(), N_meridian)
for _ in ra:
ra_span = _ * np.ones_like(dec_span)
grid_x, grid_y = self._eq2xy(np.deg2rad(dec_span),
np.deg2rad(ra_span), projection)
if show_gridlines:
mer = ax.plot(grid_x, grid_y, **plot_style)[0]
meridian[_] = mer
# DEC curves
parallel = dict()
ra_span = np.linspace(grid_lon.min(), grid_lon.max(), 200)
if polar_plot:
dec = np.linspace(grid_lat.min(), grid_lat.max(), N_parallel + 1)
else:
dec = np.linspace(grid_lat.min(), grid_lat.max(), N_parallel)
for _ in dec:
dec_span = _ * np.ones_like(ra_span)
grid_x, grid_y = self._eq2xy(np.deg2rad(dec_span),
np.deg2rad(ra_span), projection)
if show_gridlines:
par = ax.plot(grid_x, grid_y, **plot_style)[0]
parallel[_] = par
# LAT/LON ticks
if show_gridlines and show_ticks:
raise NotImplementedError("Not yet implemented.")
def _draw_data(self, index, data_kwargs, use_contours, projection, ax):
"""
Contour plot of data.
Parameters
----------
index : int, array-like(int), slice
`index` parameter given to :py:meth:`draw`.
data_kwargs : dict
`data_kwargs` parameter given to :py:meth:`draw`.
use_contours: bool
If :py:obj:`True`, use [tri]contourf() to produce the plots.
If :py:obj:`False`, use [tri]pcolor[mesh]() to produce the plots.
projection : :py:class:`~pyproj.Proj`
PyProj projection object.
ax : :py:class:`~matplotlib.axes.Axes`
Axes to plot on.
Returns
-------
scm : :py:class:`~matplotlib.cm.ScalarMappable`
"""
if data_kwargs is None:
data_kwargs = dict()
N_image = self.shape[0]
if chk.is_integer(index):
index = np.array([index], dtype=int)
elif chk.has_integers(index):
index = np.array(index, dtype=int)
else: # slice()
index = np.arange(N_image, dtype=int)[index]
if index.size == 0:
raise ValueError("No data-cube slice chosen.")
if not np.all((0 <= index) & (index < N_image)):
raise ValueError("Parameter[index] is out of bounds.")
data = np.sum(self._data[index], axis=0)
_, grid_lat, grid_lon = transform.cart2eq(*self._grid)
grid_x, grid_y = self._eq2xy(grid_lat, grid_lon, projection)
# Colormap choice
if "cmap" in data_kwargs:
obj = data_kwargs.pop("cmap")
if chk.is_instance(str)(obj):
cmap = cm.get_cmap(obj)
else:
cmap = obj
else:
cmap = cm.get_cmap("RdPu")
if self._is_gridded:
if use_contours:
scm = ax.contourf(grid_x,
grid_y,
data,
cmap.N,
cmap=cmap,
**data_kwargs)
else:
scm = ax.pcolormesh(grid_x,
grid_y,
data,
cmap=cmap,
**data_kwargs)
else:
triangulation = tri.Triangulation(grid_x, grid_y)
if use_contours:
scm = ax.tricontourf(triangulation,
data,
cmap.N,
cmap=cmap,
**data_kwargs)
else:
scm = ax.tripcolor(triangulation,
data,
cmap=cmap,
**data_kwargs)
# Show coordinates in status bar
def sexagesimal_coords(x, y):
lon, lat = projection(x, y, errcheck=False, inverse=True)
lon = (coord.Angle(lon * u.deg).wrap_at(180 * u.deg).to_string(
unit=u.hourangle, sep="hms"))
lat = coord.Angle(lat * u.deg).to_string(unit=u.degree, sep="dms")
msg = f"RA: {lon}, DEC: {lat}"
return msg
ax.format_coord = sexagesimal_coords
return scm