def curvelinear_test1(fig): """Grid for custom transform.""" def tr(x, y): sgn = np.sign(x) x, y = np.abs(np.asarray(x)), np.asarray(y) return sgn*x**.5, y def inv_tr(x, y): sgn = np.sign(x) x, y = np.asarray(x), np.asarray(y) return sgn*x**2, y grid_helper = GridHelperCurveLinear( (tr, inv_tr), extreme_finder=ExtremeFinderSimple(20, 20), # better tick density grid_locator1=MaxNLocator(nbins=6), grid_locator2=MaxNLocator(nbins=6)) ax1 = fig.add_subplot(axes_class=Axes, grid_helper=grid_helper) # ax1 will have a ticks and gridlines defined by the given # transform (+ transData of the Axes). Note that the transform of the Axes # itself (i.e., transData) is not affected by the given transform. ax1.imshow(np.arange(25).reshape(5, 5), vmax=50, cmap=plt.cm.gray_r, origin="lower")
def setup_earth_axes(fig, rect, theta_lim, h_lim, a_e, theta_scale): """ From https://matplotlib.org/examples/axes_grid/demo_floating_axes.html """ # rotate a bit for better orientation tr_rotate = Affine2D().translate( np.pi / 2 - np.mean(theta_lim) * theta_scale, 0) # scale degree to radians tr_scale = Affine2D().scale(theta_scale, 1) # treat heights tr_htrans = Affine2D().translate(0, +a_e) tr = tr_htrans + tr_scale + tr_rotate + PolarAxes.PolarTransform() grid_locator1 = MaxNLocator(5) grid_locator2 = MaxNLocator(5) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(*theta_lim, *h_lim), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=None, tick_formatter2=None, ) ax = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax) # adjust axis ax.axis["left"].set_axis_direction("top") ax.axis["left"].label.set_text("Height [m]") ax.axis["left"].toggle(ticklabels=True, label=True) ax.axis["right"].toggle(ticklabels=False, label=False) ax.axis["right"].set_axis_direction("right") ax.axis["bottom"].toggle(ticklabels=True, label=True) ax.axis["bottom"].set_axis_direction("bottom") ax.axis["bottom"].major_ticklabels.set_axis_direction("bottom") ax.axis["bottom"].label.set_axis_direction("bottom") ax.axis["bottom"].label.set_text("Distance [km]") # create a parasite axes whose transData in RA, cz aux_ax = ax.get_aux_axes(tr) aux_ax.patch = ax.patch # for aux_ax to have a clip path as in ax ax.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax, aux_ax
def setup_axes1(fig, rect): tr = Affine2D().scale(2, 1).rotate_deg(30) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(-0.5, 3.5, 0, 4), grid_locator1=MaxNLocator(nbins=4), grid_locator2=MaxNLocator(nbins=4)) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) aux_ax = ax1.get_aux_axes(tr) return ax1, aux_ax
def setup_axes2(fig, rect): tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"), (.5 * pi, r"$\frac{1}{2}\pi$")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(2) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(.5 * pi, 0, 2, 1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # 创建一个ParasiteAxes aux_ax = ax1.get_aux_axes(tr) # 让aux_ax具有一个ax中的剪切路径 aux_ax.patch = ax1.patch # 但这样做会有一个副作用,这个patch会被绘制两次,并且可能会被绘制于其它 # Artist的上面,因此用降低其zorder值的方法来阻止该情况 ax1.patch.zorder = 0.9 return ax1, aux_ax
def setup_axes2(fig, rect): #mengatur locator dan formatter tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"), (.5 * pi, r"$\frac{1}{2}\pi$")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(2) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(.5 * pi, 0, 2, 1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None, ) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch ax1.patch.zorder = 0.9 return ax1, aux_ax
def setup_axes(fig, rect, extremes): """Axes for a GAMA region""" # rotate a bit for better orientation tr_rotate = Affine2D().translate(-0.5 * (extremes[0] + extremes[1]), 0) # scale degree to radians tr_scale = Affine2D().scale(np.pi / 180., 1.) tr = tr_rotate + tr_scale + PolarAxes.PolarTransform() grid_locator1 = MaxNLocator(3) grid_locator2 = MaxNLocator(5) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=extremes, grid_locator1=grid_locator1, grid_locator2=grid_locator2) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # adjust axis ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["left"].label.set_text(r'z') ax1.axis["top"].label.set_text('RA [deg]') # create a parasite axes whose transData in RA, z aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def test_pretty_print_format(): locator = MaxNLocator() locs, nloc, factor = locator(0, 100) fmt = FormatterPrettyPrint() assert fmt("left", None, locs) == \ [r'$\mathdefault{%d}$' % (l, ) for l in locs]
def setup_axes3(fig, rect): """ Sometimes, things like axis_direction need to be adjusted. """ # rotate a bit for better orientation tr_rotate = Affine2D().translate(-95, 0) # scale degree to radians tr_scale = Affine2D().scale(np.pi / 180., 1.) tr = tr_rotate + tr_scale + PolarAxes.PolarTransform() grid_locator1 = angle_helper.LocatorHMS(4) tick_formatter1 = angle_helper.FormatterHMS() grid_locator2 = MaxNLocator(3) # Specify theta limits in degrees ra0, ra1 = 8. * 15, 14. * 15 # Specify radial limits cz0, cz1 = 0, 14000 grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(ra0, ra1, cz0, cz1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = fig.add_subplot(rect, axes_class=floating_axes.FloatingAxes, grid_helper=grid_helper) # adjust axis ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["left"].label.set_text(r"cz [km$^{-1}$]") ax1.axis["top"].label.set_text(r"$\alpha_{1950}$") # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def curvelinear_test1(fig): """Grid for custom transform.""" def tr(x, y): sgn = np.sign(x) x, y = np.abs(np.asarray(x)), np.asarray(y) return sgn * x**.5, y def inv_tr(x, y): sgn = np.sign(x) x, y = np.asarray(x), np.asarray(y) return sgn * x**2, y extreme_finder = angle_helper.ExtremeFinderCycle( 20, 20, lon_cycle=None, lat_cycle=None, # (0, np.inf), lon_minmax=None, lat_minmax=None, ) grid_helper = GridHelperCurveLinear( (tr, inv_tr), extreme_finder=extreme_finder, # better tick density grid_locator1=MaxNLocator(nbins=6), grid_locator2=MaxNLocator(nbins=6)) ax1 = Subplot(fig, 111, grid_helper=grid_helper) # ax1 will have a ticks and gridlines defined by the given # transform (+ transData of the Axes). Note that the transform of # the Axes itself (i.e., transData) is not affected by the given # transform. fig.add_subplot(ax1) ax1.imshow(np.arange(25).reshape(5, 5), vmax=50, cmap=plt.cm.gray_r, origin="lower")
def setup_axes3(fig, rect): """ Sometimes, things like axis_direction need to be adjusted. """ # scale degree to radians tr_scale = Affine2D().scale(np.pi / 180., 1.) tr = tr_scale + PolarAxes.PolarTransform() grid_locator1 = angle_helper.LocatorHMS(4) tick_formatter1 = angle_helper.FormatterHMS() grid_locator2 = MaxNLocator(3) ra0, ra1 = 0, 180 cz0, cz1 = 0, 10 grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(ra0, ra1, cz0, cz1), #grid_locator1=grid_locator1, grid_locator2=grid_locator2, #tick_formatter1=tick_formatter1, tick_formatter2=None, ) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # adjust axis ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["left"].label.set_text(r"$P(\alpha)$") ax1.axis["top"].label.set_text(r"$\alpha$") # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def setup_axes3(fig, rect): # 将坐标轴稍微旋转一下 tr_rotate = Affine2D().translate(-95, 0) # 转换弧度与度 tr_scale = Affine2D().scale(np.pi / 180., 1.) tr = tr_rotate + tr_scale + PolarAxes.PolarTransform() grid_locator1 = angle_helper.LocatorHMS(4) tick_formatter1 = angle_helper.FormatterHMS() grid_locator2 = MaxNLocator(3) # 设置theta的数值范围,以度为单位 ra0, ra1 = 8. * 15, 14. * 15 # 设置径向的数值范围 cz0, cz1 = 0, 14000 grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(ra0, ra1, cz0, cz1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # 调整axis ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["left"].label.set_text(r"cz [km$^{-1}$]") ax1.axis["top"].label.set_text(r"$\alpha_{1950}$") # 创建ParasiteAxes,其transData在(RA, cz)空间 aux_ax = ax1.get_aux_axes(tr) # 让aux_ax具有一个ax中的剪切路径,并降低其zorder值 aux_ax.patch = ax1.patch ax1.patch.zorder = 0.9 return ax1, aux_ax
def setup_axes(fig, rect, theta, radius): """ Sets up the axes in such a way we can plot the polarplot. """ tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(-4. / 8. * pi, r"$-\frac{1}{2}\pi$"), (-3. / 8. * pi, r""), (-2. / 8. * pi, r"$-\frac{1}{4}\pi$"), (-1. / 8. * pi, r""), (0. / 8. * pi, r"$0$"), (1. / 8. * pi, r""), (2. / 8. * pi, r"$\frac{1}{4}\pi$"), (3. / 8. * pi, r""), (4. / 8. * pi, r"$\frac{1}{2}\pi$"), (6. / 8. * pi, r"$\frac{3}{4}\pi$"), (8. / 8. * pi, r"$\pi$")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(3) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(theta[0], theta[1], radius[0], radius[1]), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # adjust axis # "bottom", "top", "left", "right" ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") # create a parasite axes aux_ax = ax1.get_aux_axes(tr) return ax1, aux_ax
def setup_axes2(fig, rect): """ With custom locator and formatter. Note that the extreme values are swapped. """ tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(.5 * pi, r"90$\degree$"), (.625 * pi, r"112.5$\degree$"), (.75 * pi, r"135$\degree$"), (.81111111 * pi, r"146$\degree$"), (.84444444 * pi, r"152$\degree$"), (pi, r"180$\degree$")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(2) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(pi, 0.5 * pi, 6371, 0), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) ax1.axis["bottom"].major_ticklabels.set_axis_direction("top") ax1.axis["left"].toggle(ticklabels=False) ax1.axis["left"].toggle(ticks=False) ax1.axis["top"].toggle(ticks=False) fig.add_subplot(ax1) # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def setup_axes3(fig, rect): #menentukan axis_direction tr_rotate = Affine2D().translate(-95, 0) tr_scale = Affine2D().scale(np.pi / 180., 1.) tr = tr_rotate + tr_scale + PolarAxes.PolarTransform() grid_locator1 = angle_helper.LocatorHMS(4) tick_formatter1 = angle_helper.FormatterHMS() grid_locator2 = MaxNLocator(3) ra0, ra1 = 8. * 15, 14. * 15 cz0, cz1 = 0, 14000 grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(ra0, ra1, cz0, cz1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None, ) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible("False") ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["left"].label.set_text(r"cz [km$^{-1}$]") ax1.axis["top"].label.set_text(r"$\alpha_{1950}$]") aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch #efek dari patch adalah lebih sederhana dan lebih pada tampilan lainnya ax1.patch.zorder = 0.9 return ax1, aux_ax
def setup_axes2(fig, rect): """ With custom locator and formatter. Note that the extreme values are swapped. """ #tr_scale = Affine2D().scale(np.pi/180., 1.) tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(0, r"$0$"), (.25 * pi, r"$\frac{1}{4}\pi$"), (.5 * pi, r"$\frac{1}{2}\pi$")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(2) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(.5 * pi, 0, 2, 1), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None, ) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def setup_axes2(fig, rect, tmin, tmax, zmin, zmax): """ With custom locator and formatter. Note that the extreme values are swapped. """ tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(tmin, '%.2f' % tmin), (0, r'$0$'), (tmax, '%.2f' % tmax)] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(4) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(tmax, tmin, zmax, zmin), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.95 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def setup_axes2(fig, rect): """ With custom locator and formatter. Note that the extreme values are swapped. """ tr = PolarAxes.PolarTransform() pi = np.pi angle_ticks = [(0,'180' ), (.25*pi,'135' ), (.5*pi, '90'), (.75*pi,'45' ), (pi,'0')] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(nbins=6) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(pi,0, 6371,3481), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def fractional_polar_axes(f, thlim=(0, 180), rlim=(0, 1), step=(30, 0.01), thlabel=r'$\alpha$', rlabel='z', ticklabels=True): import matplotlib.pyplot as plt from matplotlib.transforms import Affine2D from matplotlib.projections import PolarAxes from mpl_toolkits.axisartist import angle_helper from mpl_toolkits.axisartist.grid_finder import MaxNLocator from mpl_toolkits.axisartist.floating_axes import GridHelperCurveLinear, FloatingSubplot from mpl_toolkits.axisartist.grid_finder import (FixedLocator, MaxNLocator, DictFormatter) """Return polar axes that adhere to desired theta (in deg) and r limits. steps for theta and r are really just hints for the locators. Using negative values for rlim causes problems for GridHelperCurveLinear for some reason""" th0, th1 = thlim # deg r0, r1 = rlim thstep, rstep = step # scale degrees to radians: tr_scale = Affine2D().scale(np.pi/180., 1.) tr = tr_scale + PolarAxes.PolarTransform() theta_grid_locator = angle_helper.LocatorDMS((th1-th0) // thstep) r_grid_locator = MaxNLocator((r1-r0) // rstep) theta_tick_formatter = angle_helper.FormatterDMS() theta_tick_formatter = None theta_ticks = [(0, r"$90^{\circ}$"), (30, r"$120^{\circ}$"), (60, r"$150^{\circ}$"), (90, r"$180^{\circ}$"), (120, r"$210^{\circ}$"), (150, r"$270^{\circ}$"), (180, r"$0^{\circ}$")] theta_tick_formatter = DictFormatter(dict(theta_ticks)) grid_helper = GridHelperCurveLinear(tr, extremes=(th0, th1, r0, r1), grid_locator1=theta_grid_locator, grid_locator2=r_grid_locator, tick_formatter1=theta_tick_formatter, tick_formatter2=None) a = FloatingSubplot(f, 111, grid_helper=grid_helper) f.add_subplot(a) # adjust x axis (theta): a.axis["bottom"].set_visible(False) a.axis["top"].set_axis_direction("bottom") # tick direction a.axis["top"].toggle(ticklabels=ticklabels, label=bool(thlabel)) a.axis["top"].major_ticklabels.set_axis_direction("top") a.axis["top"].label.set_axis_direction("top") # adjust y axis (r): a.axis["left"].set_axis_direction("bottom") # tick direction a.axis["right"].set_axis_direction("top") # tick direction a.axis["left"].toggle(ticklabels=ticklabels, label=bool(rlabel)) # add labels: a.axis["top"].label.set_text(thlabel) a.axis["left"].label.set_text(rlabel) # create a parasite axes whose transData is theta, r: auxa = a.get_aux_axes(tr) # make aux_ax to have a clip path as in a?: auxa.patch = a.patch # this has a side effect that the patch is drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to prevent this: a.patch.zorder = -2 # add sector lines for both dimensions: thticks = grid_helper.grid_info['lon_info'][0] rticks = grid_helper.grid_info['lat_info'][0] for th in thticks[1:-1]: # all but the first and last auxa.plot([th, th], [r0, r1], '--', c='grey', zorder=-1) for ri, r in enumerate(rticks): # plot first r line as axes border in solid black only if it isn't at r=0 if ri == 0 and r != 0: ls, lw, color = 'solid', 2, 'black' else: ls, lw, color = 'dashed', 1, 'grey' # From http://stackoverflow.com/a/19828753/2020363 auxa.add_artist(plt.Circle([0, 0], radius=r, ls=ls, lw=lw, color=color, fill=False, transform=auxa.transData._b, zorder=-1)) return auxa
def plot_crosssection_any(self, lon1, lon2, lat1, lat2, numpoints=400, whattoplot='clust', title='', stretch=1, greatcirclepath=True, lon0=180, spherical=False): """ plot horizontal slices through an ses3d model plot_slice(self,depth,colormap='tomo',res='i',verbose=False) depth=depth in km of the slice colormap='tomo','mono' res=resolution of the map, admissible values are: c, l, i, h f """ model = getattr(self, whattoplot) #lon=(lon1+lon2)/2. #- set up a map and colourmap ----------------------------------------- fig = plt.figure() plt.subplot(2, 1, 1) m = Basemap(projection='hammer', lon_0=lon0) #m.drawparallels(np.arange(self.lat_min,self.lat_max,45.),labels=[0,0,0,0])#[1,0,0,1]) #m.drawmeridians(np.arange(self.lon_min,self.lon_max,60.),labels=[0,0,0,0])#[1,0,0,1]) coasts = m.drawcoastlines(zorder=1, color='white', linewidth=0) coasts_paths = coasts.get_paths() ipolygons = range(40) # want Baikal, but not Tanganyika # 80 = Superior+Michigan+Huron, 81 = Victoria, 82 = Aral, 83 = Tanganyika, # 84 = Baikal, 85 = Great Bear, 86 = Great Slave, 87 = Nyasa, 88 = Erie # 89 = Winnipeg, 90 = Ontario for ipoly in ipolygons: r = coasts_paths[ipoly] # Convert into lon/lat vertices polygon_vertices = [(vertex[0], vertex[1]) for (vertex, code) in r.iter_segments(simplify=False)] px = [polygon_vertices[i][0] for i in range(len(polygon_vertices))] py = [polygon_vertices[i][1] for i in range(len(polygon_vertices))] m.plot(px, py, linewidth=1., zorder=3, color=[0.2, 0.2, 0.2]) #m.drawmapboundary(fill_color=[1.0,1.0,1.0]) #m.drawmapboundary(fill_color=[1.0,1.0,1.0]) if lon0 == 180: z = (model[:, :, 0]) #z=z.transpose([1,0,2]) #zt,lonstmp=shiftgrid(0,z.T,self.lon) #lonst,lonstmp=shiftgrid(0,lons.T,lons[:,0]) x1, y1 = np.meshgrid(self.lon, self.lat) x, y = m(x1.T, y1.T) else: z = (model[:, :, 0]) zt, lonstmp = shiftgrid(0, z.T, self.lon, start=False) x1, y1 = np.meshgrid(self.lon, self.lat) print(np.shape(x1), np.shape(y1)) x, y = m(x1.T, y1.T) #x=m.shiftdata(x,lon_0=lon0) rgb =np.array(np.transpose(clustmap,(1,2,0)),dtype='float32') #rgb =zt.transpose([1,2,0]) #color_tuple=rgb.reshape((rgb.shape[1]*rgb.shape[0],rgb.shape[2]),order='C') #mapper=np.linspace(0.,1.,rgb.shape[1]*rgb.shape[0]).reshape(rgb.shape[0],rgb.shape[1]) #rgb_map=LinearSegmentedColormap.from_list('rgbmap',color_tuple,N=rgb.shape[1]*rgb.shape[0]) cs = m.pcolor(x, y, z, cmap=self.rgb_map, linewidth=0, rasterized=True) #plt.colorbar() inv = geo.WGS84.Inverse(lat1, lon1, lat2, lon2) points = np.linspace(0, inv['s12'], numpoints) line = geo.WGS84.Line(lat1, lon1, inv['azi1']) if greatcirclepath: [x1, y1] = m.gcpoints(lon1, lat1, lon2, lat2, numpoints) m.plot(x1, y1, 'k', linewidth=3) m.plot(x1[0], y1[0], '.c', markersize=15, markeredgecolor='k') m.plot(x1[-1], y1[-1], '.m', markersize=15, markeredgecolor='k') dist = [] lonsline = [] latsline = [] for i in range(len(points)): loc = line.Position(points[i]) # dist.append(haversine((loc['lat2'],loc['lon2']),([lat1],[lon1]))/111194.) dist.append(loc['s12'] / 111194.) lonsline.append(loc['lon2']) latsline.append(loc['lat2']) lonsline = np.array(lonsline) latsline = np.array(latsline) else: lonsline = np.linspace(lon1, lon2, numpoints) latsline = np.linspace(lat1, lat2, numpoints) dist = haversine((lat1, lon1), (latsline, lonsline)) / 111194. [x1, y1] = m(lonsline, latsline) m.plot(x1, y1, 'k', linewidth=3) m.plot(x1[0], y1[0], '.c', markersize=15, markeredgecolor='k') m.plot(x1[-1], y1[-1], '.m', markersize=15, markeredgecolor='k') modeltoplot = getattr(self, 'indg6') idxs = [] for i in range(len(lonsline)): idxs.append( np.argmin( haversine((latsline[i], lonsline[i]), (self.latg6, self.long6)))) idxs = np.array(idxs) toplot = np.empty((len(lonsline), len(self.depth))) for d in range(len(self.depth)): el = np.where(self.deps == self.depth[d]) clusttmp = np.squeeze(modeltoplot[el]) for i in range(len(lonsline)): toplot[i, d] = clusttmp[idxs[i]] #toplot.append(np.round(scipy.ndimage.map_coordinates(model[:,:,d], np.vstack((row,col)),order=0,mode='constant'))) toplot = np.array(toplot).T xx, yy = np.meshgrid(dist, self.depth) if spherical == False: ax = plt.subplot(2, 1, 2) minval = np.min(np.min(toplot)) maxval = np.max(np.max(toplot)) contours = np.round(np.linspace(-1.1, 1.1, 12), 2) plt.title(title) cs = plt.pcolor(xx, yy, toplot, cmap=self.rgb_map, vmin=0.5, vmax=21.5) plt.plot([dist[0], dist[-1]], [min(self.depth), min(self.depth)], 'k', linewidth=8) plt.plot(dist[0], min(self.depth), '.c', markersize=40, markeredgecolor='k') plt.plot(dist[-1], min(self.depth), '.m', markersize=40, markeredgecolor='k') #plt.pcolor(x,y,self.dvs[:,:,layer],vmin=-0.04, vmax=0.04,cmap=plt.cm.get_cmap('jet_r')) plt.ylim([min(self.depth), 2890]) plt.gca().invert_yaxis() plt.xlim([min(dist), max(dist)]) ax.set_aspect(.015 / stretch) #plt.xlabel(xlabel) plt.ylabel('depth (km)') if spherical == True: thetamin = 0 thetamax = inv['a12'] * np.pi / 180. tr = PolarAxes.PolarTransform() pi = np.pi shift = pi / 2 - (thetamax + thetamin) / 2 xx = xx + shift * 180. / pi angle_ticks = [(thetamin + shift, r""), ((thetamax + thetamin) / 2 + shift, r""), (thetamax + shift, r"")] grid_locator1 = FixedLocator([v for v, s in angle_ticks]) tick_formatter1 = DictFormatter(dict(angle_ticks)) grid_locator2 = MaxNLocator(6) grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(thetamin + shift, thetamax + shift, 6371, 3480), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax1 = floating_axes.FloatingSubplot(fig, 212, grid_helper=grid_helper) fig.add_subplot(ax1) # create a parasite axes whose transData in RA, cz aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. #ax=plt.subplot(212, polar = True) minval = np.min(np.min(toplot)) maxval = np.max(np.max(toplot)) contours = np.round(np.linspace(-1.1, 1.1, 12), 2) #plt.title(title) cs = aux_ax.pcolor((180. - xx) * np.pi / 180., 6371. - yy, toplot, cmap=self.rgb_map, vmin=0.5, vmax=21.5) aux_ax.plot(np.pi - (thetamin + shift), 6371., '.c', markersize=55, markeredgecolor='k') aux_ax.plot(np.pi - (thetamax + shift), 6371., '.m', markersize=55, markeredgecolor='k') return aux_ax, shift
def cone( ra, z, scale=0.5, orientation='horizontal', raaxis='min', ralim=None, zlim=None, hms=False, # cosmology=None, lookbtime=False, plot=None, fig=None, subnum=None, xlabel=r"$\alpha$", ylabel=r"$\mathsf{redshift}$", **kwargs): """ Make a wedge plot of RA/Dec vs redshift z, where RA/DEC are in degrees Parameters ---------- Input data angle : (n, ) array RA in degrees redshift : (n, ) array scale: 0.5 orientation: 'horizontal': increasing z along +ve xaxis 'vertical': increasing z along +ve yaxis angle in degrees: increasing z along the tilted axis raxis: 'min' | 'mid' | float default is 'min' RA value along which the cone plot is orientated horizontal or vertical ralim, zlim: list [ramin, rmax], list [zmin, zmax] default is taken from the lower/upper bound of the input data scatter: any kwargs compatible with plt.scatter hms: show RA labels in units of hours (if True) or degrees (if False) lookbtime: True/False plot: None 'scatter' | 'hexbin' etc fig: supply figure instance default None subnum: subplot number e.g. 111, 221 etc default None xlabel: r"$\alpha$" ylabel: r"$\mathsf{redshift}$" cosmology: dict Uses cosmolopy package to compute look-back time default cosmology is {'omega_M_0': 0.3, 'omega_lambda_0': 0.7, 'h': 0.72} kwargs ------ scatter = {'s': 4, 'marker': ','} Notes ----- --Decorations that can be done outside the code: Draw grids: ax.grid(True, alpha=0.2) Set title: ax.set_title('Wedge plot') --Look-back time as twin axis to redshift not yet implemented --In future plan is to able to put colorbar in the plot too. Using cmap option. """ # ------ Extents of ra and z if ralim: ramin, ramax = ralim else: ramin, ramax = ra.min(), ra.max() if zlim: zmin, zmax = zlim else: zmin, zmax = z.min(), z.max() # ----- Scale and Orientation of the wedge if orientation == 'horizontal': dirn = 0. elif orientation == 'vertical': dirn = 90. else: dirn = orientation if raaxis == 'min': raaxis = ramin elif raaxis == 'mid': raaxis = 0.5 * (ramin + ramax) # Tilt of a cone relative to minimum RA tr_rotate = Affine2D().translate(dirn / scale - raaxis, 0.0) # Scaling the opening angle tr_scale = Affine2D().scale(scale * np.pi / 180., 1.0) tr = tr_rotate + tr_scale + PolarAxes.PolarTransform() # ---- Grids if hms is True: grid_locator1 = angle_helper.LocatorHMS(4.0) tick_formatter1 = angle_helper.FormatterHMS() else: grid_locator1 = angle_helper.LocatorDMS(4.0) tick_formatter1 = angle_helper.FormatterDMS() grid_locator2 = MaxNLocator(10) grid_helper = GridHelperCurveLinear(tr, extremes=(ramin, ramax, zmin, zmax), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) # Figure properties if not fig: fig = plt.figure(figsize=(8, 7)) subnum = 111 ax = FloatingSubplot(fig, subnum, grid_helper=grid_helper) fig.add_subplot(ax) # adjust axis # Left, right, top represent z, lookbacktime, RA respectively. # right axes is for look-back time yet to be coded ax.axis["left"].set_axis_direction("bottom") ax.axis["right"].set_axis_direction("top") ax.axis["bottom"].set_visible(False) ax.axis["top"].set_axis_direction("bottom") ax.axis["top"].toggle(ticklabels=True, label=True) ax.axis["top"].major_ticklabels.set_axis_direction("top") ax.axis["top"].label.set_axis_direction("top") ax.axis["left"].label.set_text(ylabel) ax.axis["top"].label.set_text(xlabel) # create a parasite axes that transData in RA, z aux = ax.get_aux_axes(tr) aux.patch = ax.patch # for aux_ax to have a clip path as in ax ax.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. if plot == 'scatter': aux.scatter(ra, z, **kwargs) # plt.tight_layout() # plt.show() return ax, aux, fig
# while num < nstat: # # print num, nstat, mphs[num] # if num == 0: # dtrad[num] = math.radians( mphs[num] ) # strad[num] = math.radians( sphs[num] ) # else: # dtrad.append( math.radians( mphs[num] )) # strad.append( math.radians( sphs[num] )) # num = num + 1 #angle_ticks = [(0, r"$0$"), (.25*pi, r"$\frac{1}{4}\pi$"), (.5*pi, r"$\frac{1}{2}\pi$")] grid_locator1 = angle_helper.LocatorDMS(12) tick_formatter1 = angle_helper.FormatterDMS() grid_locator2 = MaxNLocator(2) dtrad = (np.array(mphs)) strad = (np.array(sphs)) total = np.hstack([dtrad, strad]) checkrange_s = 0 def mod_dist(a, b): return np.min([np.mod(a - b, 360), np.mod(b - a, 360)]) for a in total: for b in total: crange = mod_dist(a, b) if crange > checkrange_s:
def _setup_axes1(fig, angle, left, right, bottom, up, ax=None, rect=None): """ Stacks a rotated axes over the main one. Required arguments: ---------- *fig*: The figure that the axes are in. *angle*: A numeric limited in [-15, +15]. The angle of rotation of the canvas. *left*: A numeric. Leftmost point of the printable area. *right*: A numeric. Rightmost point of the printable area. *bottom*: A numeric. Lowest point of the printable area. *up*: A numeric. Highest point of the printable area. Return: ----------- Two axes: a background one (ax1) and a rotated one (ax). The plot will be displayed on the rotated ax. """ import mpl_toolkits.axisartist.floating_axes as floating_axes from mpl_toolkits.axisartist.grid_finder import MaxNLocator from matplotlib.transforms import Affine2D # Define height to width ratio vert = up - bottom hor = right - left ratio = vert / hor # Create rotated and scaled canvas tr = Affine2D().scale(4 * ratio, 4).rotate_deg(angle) # Rotated canvas is in the center tile of a 3x3 grid, limited by extremes grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(left, right, bottom, up), grid_locator1=MaxNLocator(nbins=4), grid_locator2=MaxNLocator(nbins=4)) if not rect: rect = 111 ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) ax = ax1.get_aux_axes(tr) for axisLoc in ['top', 'left', 'right', 'bottom']: ax1.axis[axisLoc].set_visible(False) ax.axis[axisLoc].set_visible(False) return ax, ax1
def main(): origin = [0, 0] xCoord = [1, -1] yCoord = [1, 2] transformation = [[1, 3], [5, 2]] [eigenvalue1, eigenvalue2], [eigenvector1, eigenvector2] = LA.eig(transformation) print eigenvalue1, eigenvalue2, (3 - sqrt(61)) / 2, (3 + sqrt(61)) / 2 eigenvector1 = eigenvector1 / dot(eigenvector1, eigenvector1) eigenvector2 = eigenvector2 / dot(eigenvector2, eigenvector2) eigenCoord1 = zip(origin, 3 * eigenvalue1 * eigenvector1) print eigenvector1 fig, ax = plt.subplots() x_grid_locator = MaxNLocator(3 // 0.0125) y_grid_locator = MaxNLocator(3 // 0.00625) ax = AA.Axes( fig, [0.1, 0.1, 0.8, 0.8], grid_helper=GridHelperCurveLinear( (tr, inv_tr), grid_locator1=x_grid_locator, grid_locator2=y_grid_locator)) # This appears to be your margins fig.add_axes(ax) ax.axis["right"].set_visible(False) ax.axis["top"].set_visible(False) ax.axis["left"].set_visible(False) ax.axis["bottom"].set_visible(False) ax.grid(True, zorder=0) # ax.set_xticks([0.01, 0.02, 0.03]) ax.axis["t"] = ax.new_floating_axis( 0, 0 ) # first argument appears to be slope, second argument appears to be starting point on vertical ax.axis["t2"] = ax.new_floating_axis(1, 0) # ax.axis["t"].set_xticks([1, 2, 3, 4, 5, 6]) # ax.axis["t"].label.set_pad(2) ax.plot([0, 1], [0, 1]) # ax.axis["y=0"] = ax.new_floating_axis(nth_coord=0, value=0) # # ax.axis["x=0"] = ax.new_floating_axis(nth_coord=0, value=0) # ax.axis["right2"] = ax.new_fixed_axis(loc="right", offset=(-184, 0)) # ax.axis["t"] = ax.new_floating_axis(0, 0) # first argument appears to be slope, second argument appears to be starting point on vertical # ax.axis["t2"] = ax.new_floating_axis(1, 0) scalingFactor = (24 * sqrt(29)) / 5 otherFactor = 12 * sqrt(5) print scalingFactor / 3 print otherFactor / 3 ax.set_xlim(-scalingFactor, scalingFactor) ax.set_ylim(-otherFactor, otherFactor) ax.quiver(origin, origin, xCoord, yCoord, color=[colorDefault(0), colorDefault(3)], angles='xy', scale_units='xy', scale=1) ax.grid(True, which='both') ax.axhline(y=0, color='k') ax.axvline(x=0, color='k') # axis_to_data = ax.transAxes + ax.transData.inverted() # points_data = axis_to_data.transform((2, 3)) # data_to_axis = axis_to_data.inverted() # numpy.testing.assert_allclose((2, 3), data_to_axis.transform(points_data)) plt.xlim(-8, 8) plt.ylim(-8, 8) plt.figure() plt.quiver(origin, origin, xCoord, yCoord, color=[colorDefault(0), colorDefault(3)], angles='xy', scale_units='xy', scale=1) plt.grid(True, which='both') plt.axhline(y=0, color='k') plt.axvline(x=0, color='k') # axis_to_data = ax.transAxes + ax.transData.inverted() # points_data = axis_to_data.transform((2, 3)) # data_to_axis = axis_to_data.inverted() # numpy.testing.assert_allclose((2, 3), data_to_axis.transform(points_data)) plt.xlim(-8, 8) plt.ylim(-8, 8) fig = plt.figure() x_grid_locator = MaxNLocator(3 // 0.0125) y_grid_locator = MaxNLocator(3 // 0.00625) ax = AA.Axes( fig, [0.1, 0.1, 0.8, 0.8], grid_helper=GridHelperCurveLinear( (tr, inv_tr), grid_locator1=x_grid_locator, grid_locator2=y_grid_locator)) # This appears to be your margins fig.add_axes(ax) ax.axis["right"].set_visible(False) ax.axis["top"].set_visible(False) ax.axis["left"].set_visible(False) ax.axis["bottom"].set_visible(False) ax.grid(True, zorder=0) # ax.set_xticks([0.01, 0.02, 0.03]) ax.axis["t"] = ax.new_floating_axis( 0, 0 ) # first argument appears to be slope, second argument appears to be starting point on vertical ax.axis["t2"] = ax.new_floating_axis(1, 0) # ax.axis["t"].set_xticks([1, 2, 3, 4, 5, 6]) # ax.axis["t"].label.set_pad(2) ax.plot([0, 1], [0, 1]) # ax.axis["y=0"] = ax.new_floating_axis(nth_coord=0, value=0) # # ax.axis["x=0"] = ax.new_floating_axis(nth_coord=0, value=0) # ax.axis["right2"] = ax.new_fixed_axis(loc="right", offset=(-184, 0)) # ax.axis["t"] = ax.new_floating_axis(0, 0) # first argument appears to be slope, second argument appears to be starting point on vertical # ax.axis["t2"] = ax.new_floating_axis(1, 0) scalingFactor = (24 * sqrt(29)) / 5 otherFactor = 12 * sqrt(5) print scalingFactor / 3 print otherFactor / 3 ax.set_xlim(-scalingFactor, scalingFactor) ax.set_ylim(-otherFactor, otherFactor) plt.show()
def setup_axes(fig, rect, theta, radius, quad): # quad controls the quadrant of the plot and controls the orientation # of the plot where quad=1 is upper left, 2 is upper right, 3 is # lower left, 4 is lower right if quad == 1: tr_rotate = Affine2D().translate(np.pi / 2.0, 0) elif quad == 2: tr_rotate = Affine2D().translate(0, 0) elif quad == 3: tr_rotate = Affine2D().translate(np.pi, 0) else: tr_rotate = Affine2D().translate(3.0 * np.pi / 2.0, 0) tr_scale = Affine2D().scale(np.pi / 180., 1.) # PolarAxes.PolarTransform takes radian. However, we want our coordinate # system in degree tr = tr_scale + tr_rotate + PolarAxes.PolarTransform() # Find grid values appropriate for the coordinate (degree). # The argument is an approximate number of grids. grid_locator1 = angle_helper.LocatorD(2) # And also use an appropriate formatter: tick_formatter1 = angle_helper.FormatterDMS() # set up number of ticks for the r-axis grid_locator2 = MaxNLocator(5) grid_locator1 = MaxNLocator(6) # the extremes are passed to the function thetaMin = 0 thetaMax = 90 grid_helper = floating_axes.GridHelperCurveLinear( tr, extremes=(thetaMin, thetaMax, radius[0], radius[1]), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None, ) ax1 = floating_axes.FloatingSubplot(fig, rect, grid_helper=grid_helper) fig.add_subplot(ax1) print ax1.get_xlim() print ax1.get_ylim() # adjust axis # the axis artist lets you call axis with # "bottom", "top", "left", "right" ax1.axis["left"].set_axis_direction("bottom") ax1.axis["right"].set_axis_direction("top") ax1.axis["bottom"].set_visible(False) ax1.axis["top"].set_axis_direction("bottom") ax1.axis["top"].toggle(ticklabels=True, label=True) ax1.axis["top"].major_ticklabels.set_axis_direction("top") ax1.axis["top"].label.set_axis_direction("top") ax1.axis["top"].label.set_text(ur"$\Phi$") # Set the axis labels based on the quadrant if quad == 1: # Set visibilities ax1.axis["right"].set_visible(True) ax1.axis["left"].set_visible(True) ax1.axis["right"].toggle(ticklabels=True, label=True) ax1.axis["left"].toggle(ticklabels=False, label=False) # Tick Labels #ax1.axis["right"].major_ticks.set_axis_direction('right') ax1.axis["right"].major_ticklabels.set_axis_direction('bottom') #ax1.axis["right"].major_ticklabels.set_pad(-20) #ax1.axis["right"].set_axis_direction('top') #ax1.axis["right"].set_ticklabel_direction('+') # Axis labels ax1.axis["right"].label.set_rotation(0) ax1.axis["right"].label.set_text("$D$ (kpc)") ax1.axis["right"].label.set_pad(20) elif quad == 2: ax1.axis["left"].set_visible(True) ax1.axis["left"].toggle(ticklabels=True, label=True) ax1.axis["left"].major_ticklabels.set_axis_direction("bottom") ax1.axis["left"].set_axis_direction("bottom") ax1.axis["left"].label.set_text("$D$ (kpc)") elif quad == 3: # Set visibilities ax1.axis["right"].set_visible(True) ax1.axis["left"].set_visible(True) ax1.axis["right"].toggle(ticklabels=False, label=False) ax1.axis["left"].toggle(ticklabels=True, label=True) # Tick Labels #ax1.axis["right"].major_ticks.set_axis_direction('right') ax1.axis["left"].major_ticklabels.set_axis_direction('top') #ax1.axis["right"].major_ticklabels.set_pad(-20) #ax1.axis["right"].set_axis_direction('top') #ax1.axis["right"].set_ticklabel_direction('+') # Axis labels ax1.axis["left"].label.set_rotation(180) ax1.axis["left"].label.set_text("$D$ (kpc)") ax1.axis["left"].label.set_pad(20) else: # Set visibilities ax1.axis["right"].set_visible(True) ax1.axis["left"].set_visible(True) ax1.axis["right"].toggle(ticklabels=True, label=True) ax1.axis["left"].toggle(ticklabels=False, label=False) # Tick Labels #ax1.axis["right"].major_ticks.set_axis_direction('right') ax1.axis["right"].major_ticklabels.set_axis_direction('top') #ax1.axis["right"].major_ticklabels.set_pad(-20) #ax1.axis["right"].set_axis_direction('top') #ax1.axis["right"].set_ticklabel_direction('+') # Axis labels ax1.axis["right"].label.set_rotation(180) ax1.axis["right"].label.set_text("$D$ (kpc)") ax1.axis["right"].label.set_pad(0) ax1.grid(True) # create a parasite axes aux_ax = ax1.get_aux_axes(tr) aux_ax.patch = ax1.patch # for aux_ax to have a clip path as in ax ax1.patch.zorder = 0.9 # but this has a side effect that the patch is # drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to # prevent this. return ax1, aux_ax
def fractional_polar_axes(f, thlim=(0, 180), rlim=(0, 1), step=(30, 0.25), thlabel='theta', rlabel='r', ticklabels=True, rlabels = None, subplot=111): '''Return polar axes that adhere to desired theta (in deg) and r limits. steps for theta and r are really just hints for the locators.''' th0, th1 = thlim # deg r0, r1 = rlim thstep, rstep = step # scale degrees to radians: tr_scale = Affine2D().scale(np.pi/180., 1.) pa = PolarAxes tr = tr_scale + pa.PolarTransform() theta_grid_locator = angle_helper.LocatorDMS((th1-th0)//thstep) r_grid_locator = MaxNLocator((r1-r0)//rstep) theta_tick_formatter = angle_helper.FormatterDMS() if rlabels: rlabels = DictFormatter(rlabels) grid_helper = GridHelperCurveLinear(tr, extremes=(th0, th1, r0, r1), grid_locator1=theta_grid_locator, grid_locator2=r_grid_locator, tick_formatter1=theta_tick_formatter, tick_formatter2=rlabels) a = FloatingSubplot(f, subplot, grid_helper=grid_helper) f.add_subplot(a) # adjust x axis (theta): a.axis["bottom"].set_visible(False) a.axis["top"].set_axis_direction("bottom") # tick direction a.axis["top"].toggle(ticklabels=ticklabels, label=bool(thlabel)) a.axis["top"].major_ticklabels.set_axis_direction("top") a.axis["top"].label.set_axis_direction("top") a.axis["top"].major_ticklabels.set_pad(10) # adjust y axis (r): a.axis["left"].set_axis_direction("bottom") # tick direction a.axis["right"].set_axis_direction("top") # tick direction a.axis["left"].toggle(ticklabels=True, label=bool(rlabel)) # add labels: a.axis["top"].label.set_text(thlabel) a.axis["left"].label.set_text(rlabel) # create a parasite axes whose transData is theta, r: auxa = a.get_aux_axes(tr) # make aux_ax to have a clip path as in a?: auxa.patch = a.patch # this has a side effect that the patch is drawn twice, and possibly over some other # artists. So, we decrease the zorder a bit to prevent this: a.patch.zorder = -2 # add sector lines for both dimensions: thticks = grid_helper.grid_info['lon_info'][0] rticks = grid_helper.grid_info['lat_info'][0] for th in thticks[1:-1]: # all but the first and last auxa.plot([th, th], [r0, r1], ':', c='grey', zorder=-1, lw=0.5) for ri, r in enumerate(rticks): # plot first r line as axes border in solid black only if it isn't at r=0 if ri == 0 and r != 0: ls, lw, color = 'solid', 1, 'black' else: ls, lw, color = 'dashed', 0.5, 'grey' # From http://stackoverflow.com/a/19828753/2020363 auxa.add_artist(plt.Circle([0, 0], radius=r, ls=ls, lw=lw, color=color, fill=False, transform=auxa.transData._b, zorder=-1)) return auxa
def __init__(self, rotation, ra_min, ra_max, z_min, z_max, stretch=1, nrows=1, ncols=1, npar=1, width=8.0, aspect=0.8, gridspec=None, blank=True, fontsize=16, legend_fontsize=14, family='serif', style='Times', weight='normal', usetex=False): super(ConePlot, self).__init__(nrows, ncols, npar, width, aspect, gridspec, blank, fontsize, legend_fontsize, family, style, weight, usetex) # Rotate for better orientation: rotate = Affine2D().translate(rotation, 0) # Scale degree to radians: scale = Affine2D().scale(np.pi * stretch / 180, 1) transform = rotate + scale + PolarAxes.PolarTransform() grid_locator1 = angle_helper.LocatorHMS(4) grid_locator2 = MaxNLocator(5) tick_formatter1 = angle_helper.FormatterHMS() self.grid_helper = floating_axes.GridHelperCurveLinear( transform, extremes=(ra_min, ra_max, z_min, z_max), grid_locator1=grid_locator1, grid_locator2=grid_locator2, tick_formatter1=tick_formatter1, tick_formatter2=None) ax = floating_axes.FloatingSubplot(self, 111, grid_helper=self.grid_helper) ax.axis['left'].set_axis_direction('bottom') ax.axis['right'].set_axis_direction('top') ax.axis['bottom'].set_visible(False) ax.axis['top'].set_axis_direction('bottom') ax.axis['top'].toggle(ticklabels=True, label=True) ax.axis['top'].major_ticklabels.set_axis_direction('top') ax.axis['top'].label.set_axis_direction('top') ax.axis['left'].label.set_text('Redshift') ax.axis['top'].label.set_text('RA (J2000)') aux_ax = ax.get_aux_axes(transform) aux_ax.patch = ax.patch ax.patch.zorder = 0.9 self.add_subplot(ax) self.aux_ax = aux_ax