def __init__(self, *args, **kwargs): """ See Axes base class for args and kwargs documentation """ #Uncomment to have the possibility to change the resolution directly #when the instance is created #self.RESOLUTION = kwargs.pop('resolution', 100) PolarAxes.__init__(self, *args, **kwargs) self.set_aspect('equal', adjustable='box', anchor='C') self.radii_angle = 67.5 self.cla()
def cla(self): """ Clear the current axes """ PolarAxes.cla(self) self.theta_angles = np.arange(0, 360, 45) self.theta_labels = ['E', 'N-E', 'N', 'N-W', 'W', 'S-W', 'S', 'S-E'] self.set_thetagrids(angles=self.theta_angles, labels=self.theta_labels) self._info = {'dir': list(), 'bins': list(), 'table': list()} self.patches_list = list()
def __init__(self, *args, **kwargs): """ See Axes base class for args and kwargs documentation """ # Uncomment to have the possibility to change the resolution directly # when the instance is created # self.RESOLUTION = kwargs.pop('resolution', 100) self.rmax = kwargs.pop("rmax", None) self.theta_labels = kwargs.pop("theta_labels", ["E", "N-E", "N", "N-W", "W", "S-W", "S", "S-E"]) PolarAxes.__init__(self, *args, **kwargs) self.set_aspect("equal", adjustable="box", anchor="C") self.radii_angle = 67.5 self.cla()
def cla(self): """ Clear the current axes """ PolarAxes.cla(self) self.theta_angles = np.arange(0, 360, 45) self.set_thetagrids(angles=self.theta_angles, labels=self.theta_labels) self._info = {"dir": list(), "bins": list(), "table": list()} self.patches_list = list() self.calm_count = None
def cla(self): """ Clear the current axes """ PolarAxes.cla(self) self.theta_angles = np.arange(0, 360, 45) self.theta_labels = ['E', 'N-E', 'N', 'N-W', 'W', 'S-W', 'S', 'S-E'] self.set_thetagrids(angles=self.theta_angles, labels=self.theta_labels) self._info = {'dir' : list(), 'bins' : list(), 'table' : list()} self.patches_list = list()
def _gen_axes_spines(self): if frame == 'circle': return PolarAxes._gen_axes_spines(self) # The following is a hack to get the spines (i.e. the axes frame) # to draw correctly for a polygon frame. # spine_type must be 'left', 'right', 'top', 'bottom', or `circle`. spine_type = 'circle' verts = unit_poly_verts(theta + np.pi / 2) # close off polygon by repeating first vertex verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def __init__(self, **kwargs): """Construct a WindrosePlot.""" self.fig = plt.figure(figsize=(8, 8), dpi=100, facecolor="w", edgecolor="w") rect = [0.12, 0.12, 0.76, 0.76] self.ax = PolarAxes(self.fig, rect, theta_offset=np.pi / 2.0, theta_direction=-1) self.ax.set_xticks(np.arange(0, 2.0 * np.pi - 0.01, 2.0 * np.pi / 8.0)) self.ax.set_xticklabels(LABELS) self.fig.add_axes(self.ax) self.table = None self.calm_percent = None self.rmax = kwargs.get("rmax")
def _gen_axes_spines(self): if frame == "circle": return PolarAxes._gen_axes_spines(self) spine_type, verts = "circle", unit_poly_verts(theta) verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def _gen_axes_spines(self): if self.radar_patch_type == 'circle': return PolarAxes._gen_axes_spines(self) spine_type = 'circle' verts = unit_poly_verts(self.radar_theta) verts.append(verts[0]) path = Path(verts) spine = Spine(self, self.radar_spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def _gen_axes_spines(self): if frame == 'circle': return PolarAxes._gen_axes_spines(self) spine_type = 'circle' verts = unit_poly_verts(theta) verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def cla(self): """ Clear the current axes """ PolarAxes.cla(self) theta_delta = 30 self.theta_angles = np.arange(0, 360, theta_delta) # self.theta_labels = ['E', 'N-E', 'N', 'N-W', 'W', # 'S-W', 'S', 'S-E'] first_quad = range(90, -1, -theta_delta) quads = range(330, 89, -theta_delta) all_quads = first_quad + quads self.theta_labels = [str(a) for a in all_quads] self.set_thetagrids(angles=self.theta_angles, labels=self.theta_labels) self._info = {'dir': list(), 'bins': list(), 'table': list()} self.patches_list = list()
def _gen_axes_spines(self): if frame == 'circle': return PolarAxes._gen_axes_spines(self) spine_type = 'circle' verts = unit_poly_verts(theta) # close off polygon by repeating first vertex verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def _gen_axes_spines(self): if self.radar_patch_type == 'circle': return PolarAxes._gen_axes_spines(self) # The following is a hack to get the spines (i.e. the axes frame) # to draw correctly for a polygon frame. spine_type = 'circle' verts = unit_poly_verts(self.radar_theta) # close off polygon by repeating first vertex verts.append(verts[0]) path = Path(verts) spine = Spine(self, self.radar_spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def _gen_axes_spines(self): if frame == 'circle': return PolarAxes._gen_axes_spines(self) # The following is a hack to get the spines (i.e. the axes frame) # to draw correctly for a polygon frame. # spine_type must be 'left', 'right', 'top', 'bottom', or `circle`. spine_type = 'circle' verts = unit_poly_verts(theta) # close off polygon by repeating first vertex verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
def plainify_rose_plot(fig: Figure, ax: PolarAxes): """ Make plain version of rose plots with only bars. """ ax.set_title("") for txt in ax.texts: txt.set_visible(False) ax.set_rgrids([]), ax.set_thetagrids([]), ax.set_axis_off() fig.patch.set_alpha(1) ax.patch.set_alpha(1)
def _gen_axes_spines(self): if frame == 'circle': return PolarAxes._gen_axes_spines(self) # The following is a hack to get the spines (i.e. the axes frame) # to draw correctly for a polygon frame. # spine_type haruslah 'left', 'right', 'top', 'bottom', or `circle`. spine_type = 'circle' verts = unit_poly_verts(theta) # menghentikan sementara polygon dengan mengulangi vertex awal verts.append(verts[0]) path = Path(verts) spine = Spine(self, spine_type, path) spine.set_transform(self.transAxes) return {'polar': spine}
class WindrosePlot: """A plot that has a single windrose on it.""" def __init__(self, **kwargs): """Construct a WindrosePlot.""" self.fig = plt.figure(figsize=(8, 8), dpi=100, facecolor="w", edgecolor="w") rect = [0.12, 0.12, 0.76, 0.76] self.ax = PolarAxes(self.fig, rect, theta_offset=np.pi / 2.0, theta_direction=-1) self.ax.set_xticks(np.arange(0, 2.0 * np.pi - 0.01, 2.0 * np.pi / 8.0)) self.ax.set_xticklabels(LABELS) self.fig.add_axes(self.ax) self.table = None self.calm_percent = None self.rmax = kwargs.get("rmax") def barplot(self, direction, speed, bins, nsector): """Do the bar plotting work.""" # compute histogram self.calm_percent, dir_centers, self.table = histogram( speed, direction, bins, nsector) theta = dir_centers.to(units("radian")).m base = np.zeros(dir_centers.m.shape[0]) width = (theta[1] - theta[0]) * 0.8 for col in range(self.table.shape[1]): if col < (bins.m.shape[0] - 1): label = "%s - %s" % (bins.m[col], bins.m[col + 1]) else: label = "%s+" % (bins.m[col], ) self.ax.bar( theta, self.table[:, col].m, bottom=base, width=width, align="center", label=label, ) base += self.table[:, col].m if self.rmax is not None: self.ax.set_ylim(0, self.rmax) # Place axis label in least congested spot self.ax.set_rlabel_position(dir_centers.m[np.argmin(base)]) # Append a % on the label self.ax.yaxis.set_major_formatter(FormatStrFormatter("%.1f%%")) # Draw Legend self.ax.legend( bbox_to_anchor=(0.01, -0.15, 0.98, 0.09), loc="center", ncol=6, fontsize=10, mode=None, columnspacing=0.9, handletextpad=0.75, # Ugly hack here due to aliasing in pint for mph title="Wind Speed [%s]" % ("mph" if bins.units == units("mph") else bins.units, ), ) def plot_calm(self): """Clear out the center and plot the calm value.""" maxval = np.max(np.sum(self.table, axis=1)) # Clear out the center for plotting the calm percentage self.ax.set_rorigin(0 - maxval.m * 0.2) # Place Calm Percent in the middle self.ax.text( 0.5, 0.5, "Calm\n%.1f%%" % (self.calm_percent.m, ), ha="center", va="center", transform=self.ax.transAxes, ) def draw_logo(self): """Brand the plot.""" datadir = os.sep.join([os.path.dirname(__file__), "..", "data"]) im = mpimage.imread("%s/%s" % (datadir, "logo.png")) plt.figimage(im, 10, 735) def draw_arrows(self): """Place arrows on the border.""" rmin, rmax = self.ax.get_ylim() for x in self.ax.get_xticks(): # https://github.com/matplotlib/matplotlib/issues/5344 self.ax.annotate( "", xy=(x + 0.001, rmax - (rmax - rmin) * 0.12), xytext=(x + 0.001, rmax + (rmax - rmin) * 0.02), arrowprops=dict( facecolor="None", edgecolor="k", alpha=0.8, shrink=0.09, zorder=10, ), ha="center", va="center", zorder=Z_OVERLAY2, )
def _gen_axes_spines(self): """Overwrite method""" return PolarAxes._gen_axes_spines(self)
def Taylor_diag(series, smax=1.5): """ Taylor Diagram : obs is reference data sample in a full diagram (0 --> npi) -------------------------------------------------------------------------- Input: series - dict with all time series (lists) to analyze series[0] - is the observation, the reference by default. """ corr,std ={},{} for i in series.keys(): corr[i] = ma.corrcoef(series[0],series[i])[1,0] std[i] = ma.std(series[i])/ma.std(series[0]) ref = 1# ma.std(series[0]) # radial grid # rlocs = np.concatenate((np.arange(0,1,0.2),[0.95,0.99])) # correlation coefficient tick marks rlocs = [0, .3, .6, .8, .95, .99] str_rlocs = np.concatenate((np.arange(0,1,0.2),[0.95,0.99],np.arange(0,10,0.2),[0.95,0.99])) tlocs = np.arccos(rlocs) # Conversion to polar angles gl1 = GF.FixedLocator(tlocs) # Positions tf1 = GF.DictFormatter(dict(zip(tlocs, map("{:.2f}".format, rlocs)))) # circumferencial grid str_locs2 = tlocs2 = np.arange(0, 2, 0.2) g22 = GF.FixedLocator(tlocs2) tf2 = GF.DictFormatter(dict(zip(tlocs2, map("{:.1f}".format, str_locs2)))) tr = PolarAxes.PolarTransform() smin = 0 ghelper = FA.GridHelperCurveLinear(tr, extremes=(0, np.pi/2, # 1st quadrant smin,smax), grid_locator1=gl1, tick_formatter1=tf1, tick_formatter2=tf2, ) fig = plt.figure(figsize=(7, 5), dpi=100) ax = FA.FloatingSubplot(fig, 111, grid_helper=ghelper) fig.add_subplot(ax) 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["top"].label.set_text("Correlation Coefficient") ax.axis["left"].set_axis_direction("bottom") ax.axis["left"].label.set_text("Standard Deviation") ax.axis["right"].set_axis_direction("top") ax.axis["right"].toggle(ticklabels=True, label=True) ax.axis["right"].set_visible(True) ax.axis["right"].major_ticklabels.set_axis_direction("bottom") #ax.axis["right"].label.set_text("Standard Deviation") ax.axis["bottom"].set_visible(False) ax.grid(True) ax = ax.get_aux_axes(tr) # radial RMS error lines from observed. t = np.linspace(0, np.pi) r = np.zeros_like(t) + ref ax.plot(t, r, 'k--', label='_') rs,ts = np.meshgrid(np.linspace(smin,smax), np.linspace(0,np.pi)) rms = np.sqrt(ref**2 + rs**2 - 2*ref*rs*np.cos(ts)) # CS = ax.contour(ts, rs, rms, colors='k', alpha=0.6, linewidths=1) # plt.clabel(CS, inline=1, fontsize=10) # plot observed point ax.plot(np.arccos(0.9999),ref,'k',marker='*',ls='', ms=10, label='Observed') # plot modelled points aux = [k for k in series.keys() if k != 0] for i in aux: ax.scatter(np.arccos(corr[i]), std[i], marker='o', label=i, zorder=5, s=50) # ax.text(np.arccos(corr[i]), std[i], i) plt.legend(bbox_to_anchor=(1.7, 1),prop=dict(size='large'),loc='best', fontsize=8) return fig, ax