def polygon(i, j, m, n, x, y, k=0, col='black'): if k == 1: return pylab.Polygon([(j * m / (x + 2), -n / (y + 2) * i), ((j + 1) * m / (x + 2), -n / (y + 2) * i), ((j + 1) * m / (x + 2), -n / (y + 2) * (i + 1)), (j * m / (x + 2), -n / (y + 2) * (i + 1))], color=col) else: return pylab.Polygon([((j + 1) * m / (x + 2), -n / (y + 2) * (i + 1)), ((j + 2) * m / (x + 2), -n / (y + 2) * (i + 1)), ((j + 2) * m / (x + 2), -n / (y + 2) * (i + 2)), ((j + 1) * m / (x + 2), -n / (y + 2) * (i + 2))], color=col)
def rectangle(self, lon1, lat1, lon2, lat2, c='0.3', shading=None, step=100): """Draw a projection correct rectangle on the map.""" class pos: x = np.array([]) y = np.array([]) def line(lons, lats): x, y = self(lons, lats) self.plot(x, y, c=c) pos.x = np.hstack((pos.x, x)) pos.y = np.hstack((pos.y, y)) line([lon1] * step, np.linspace(lat1, lat2, step)) line(np.linspace(lon1, lon2, step), [lat1] * step) line([lon2] * step, np.linspace(lat2, lat1, step)) line(np.linspace(lon2, lon1, step), [lat2] * step) if shading: p = pl.Polygon(list(zip(pos.x, pos.y)), facecolor=shading, edgecolor=c, alpha=0.5, linewidth=1) pl.gca().add_patch(p)
def rbox(ax, data, **keywords): """ Create a ggplot2 style boxplot, is eqivalent to calling ax.boxplot with the following additions: Keyword arguments: colors -- array-like collection of colours for box fills names -- array-like collection of box names which are passed on as tick labels """ hasColors = 'colors' in keywords if hasColors: colors = keywords['colors'] keywords.pop('colors') if 'names' in keywords: ax.tickNames = plt.setp(ax, xticklabels=keywords['names']) keywords.pop('names') bp = ax.boxplot(data, **keywords) pylab.setp(bp['boxes'], color='black') pylab.setp(bp['whiskers'], color='black', linestyle='solid') pylab.setp(bp['fliers'], color='black', alpha=.9, marker='o', markersize=3) pylab.setp(bp['medians'], color='black') numBoxes = len(data) for i in range(numBoxes): box = bp['boxes'][i] boxX = [] boxY = [] for j in range(5): boxX.append(box.get_xdata()[j]) boxY.append(box.get_ydata()[j]) boxCoords = zip(boxX, boxY) if hasColors: boxPolygon = pylab.Polygon(boxCoords, facecolor=colors[i % len(colors)]) else: boxPolygon = pylab.Polygon(boxCoords, facecolor='0.95') ax.add_patch(boxPolygon) return bp
def draw(self, axes, figure, color): poly = plt.Polygon(zip(self.xcoords, self.ycoords)) poly.set_linewidth(1) poly.set_alpha(1) poly.set_edgecolor(color) poly.set_facecolor('none') poly.set_hatch('//') patch = axes.add_patch(poly) figure.canvas.draw() return patch
def draw_static_geo(ax_xy, ax_yz, ax_xz): Np, ro, tfinal, x_lim, y_lim, z_lim, xi_lim, yi_lim, zi_lim = time_pos_ax_limits( ) py.gcf().sca(ax_xy) substrate_xy = py.Rectangle((x_lim[0], y_lim[0]), (x_lim[1] - x_lim[0]), (y_lim[1] - y_lim[0]), fc=cl_lgrey) py.gca().add_patch(substrate_xy) for kk in range(-2, 3): rectangle = py.Rectangle( (x_lim[0] / 2, -elec_width / 2 + kk * elec_spacing), x_lim[1], elec_width, fc=cl_royal_blue) py.gca().add_patch(rectangle) # ax.add_patch(rectangle) py.gcf().sca(ax_yz) substrate_yz = py.Rectangle((y_lim[0], z_lim[0]), (x_lim[1] - x_lim[0]), abs(z_lim[0]), fc=cl_dgrey, ec='k') py.gca().add_patch(substrate_yz) py.gcf().sca(ax_xz) substrate_xz = py.Rectangle((x_lim[0], z_lim[0]), (x_lim[1] - x_lim[0]), abs(z_lim[0]), fc=cl_dgrey, ec='k') py.gca().add_patch(substrate_xz) # Draw fluidic/reflecting geometries py.gcf().sca(ax_xy) w_type = geo_element_types() # Loop over all types of geometry segments for wt in range(w_type.shape[0]): fname = 'geo_points' + str( w_type[wt]) + '()' # name of the corresponding geometry function # Evaluate geo_points*()function by string name p_w, z_w = eval(fname) Nwalls = p_w.shape[0] # Draw all sements of a particular type of geometry for m in range(Nwalls): f_wall_xy = py.Polygon(p_w[m], closed=True, fc=cl_army_green, ec='k') py.gca().add_patch(f_wall_xy) return 0
def drawPolygons (axes): """ Рисование многоугольника """ polygon_1 = pylab.Polygon ([(0, -0.75), (0, -1.25), (0.5, -1.25), (1, -0.75)]) axes.add_patch (polygon_1) pylab.text (0.6, -0.7, "Polygon", horizontalalignment="center") polygon_2 = pylab.Polygon ([(-0.5, 0), (-1, -0.5), (-1, -1), (-0.5, -1)], fill = False, closed = False) axes.add_patch (polygon_2) pylab.text (-1.0, -0.1, "Polygon", horizontalalignment="center")
def plot_vector_list2d(vectors, polygon=False, **kwargs): x = [] y = [] points = [] for v in vectors: x.append(v.x) y.append(v.y) points.append([x, y]) if polygon: pylab.Polygon(points, **kwargs) else: pylab.plot(x, y, **kwargs)
def plot(self, flip=False, ax_channels=None, ax=None, *args, **kwargs): """ {_gate_plot_doc} """ if ax == None: ax = pl.gca() if ax_channels is not None: flip = self._find_orientation(ax_channels) if flip: vert = [v[::-1] for v in self.vert] else: vert = self.vert kwargs.setdefault('fill', False) kwargs.setdefault('color', 'black') poly = pl.Polygon(vert, *args, **kwargs) return ax.add_artist(poly)
def plothistCI(a, b, l, u): ''' >>> x=np.random.randn(1000) >>> bn=np.linspace(-3,3,41) >>> a,b,l,u=histCI(x,bins=bn) >>> plothistCI(a,b,l,u) ''' b = b[:-1] + np.diff(b) / 2. plt.plot(b, a, color=CLR) x = np.concatenate([b, b[::-1]]) ci = np.concatenate([u, l[::-1]]) plt.gca().add_patch( plt.Polygon(np.array([x, ci]).T, alpha=0.2, fill=True, fc='red', ec='red'))
def draw_ROI(self, im=None, color='r'): """Draw the ROI on an image""" plt.ion() ax = im.axes if hasattr(self, 'xcoords'): # it's a polygon poly = plt.Polygon(zip(self.xcoords, self.ycoords)) poly.set_linewidth(1) poly.set_alpha(1) poly.set_edgecolor(color) poly.set_facecolor('none') ax.add_patch(poly) elif hasattr(self, 'circ'): # it's a circle mycirc = plt.Circle(self.circ.center, self.circ.radius) mycirc.set_linewidth(1) mycirc.set_alpha(1) mycirc.set_edgecolor(color) mycirc.set_facecolor('none') ax.add_artist(mycirc)
def fillcontinents(self, color='#9887ff', lake_color='b', ax=None, zorder=None, alpha=None, ocean_color='w', ocean_alpha=1, edge_color='k', coast_color='none'): if not ax: ax = pl.gca() if self.projection[0] == 's': Lat0 = -90 else: Lat0 = 90 # boundary: xc, yc = self([0, 0], [Lat0, self.boundinglat]) xc0, yc0 = xc[0], yc[0] r = np.sqrt((xc[1] - xc[0])**2 + (yc[1] - yc[0])**2) circle = pl.Circle((xc0, yc0), r, facecolor=ocean_color, edgecolor=edge_color, clip_on=0, alpha=ocean_alpha, zorder=zorder) ax.add_patch(circle) for i in range(len(self.coastpolygons)): xy = zip(*self.coastpolygons[i]) if self.coastpolygontypes[i] == 1: cor = color else: cor = lake_color poly = pl.Polygon(xy, edgecolor=coast_color, facecolor=cor, alpha=alpha, zorder=zorder) axpoly = ax.add_patch(poly) axpoly.set_clip_path(circle) self._tasks(ax) self.clipping_path = circle
def draw_car(ax, s, car_length=car_length, **kwargs): # parse the state x, y, alpha, speed, theta = s # rotation matrix for the car relative to the current universe dx, dy = cos(alpha), sin(alpha) R = array([(dx, -dy), (dy, dx)]) assert linalg.det(R) > 0. # scale the coordinate system so that the car's length is 1 R *= car_length # rotation matrix of the wheels relative to the car Rwheel = array([(cos(theta), -sin(theta)), (sin(theta), cos(theta))]) # rotation matrix of the wheels relative to the current universe Rwheel = dot(R, Rwheel) # body of the car in the curernt universe body = dot([(-2, -1), (2, -1), (2, 1), (-2, 1)], R.T) + (x, y) # the front axle, in the current universe axle = dot([(2, -1.5), (2, 1.5)], R.T) + (x, y) # a wheel. a vertical segment in its own coordinate system wheel = dot([(-.5, 0), (.5, 0)], Rwheel.T) hbody = P.Polygon(body, fill=False, edgecolor=kwargs.get('color', 'b')) haxle = P.Line2D(axle[:, 0], axle[:, 1], **kwargs) hleftwheel = P.Line2D([axle[0, 0] + wheel[:, 0]], [axle[0, 1] + wheel[:, 1]], **kwargs) hrightwheel = P.Line2D([axle[1, 0] + wheel[:, 0]], [axle[1, 1] + wheel[:, 1]], **kwargs) hcenter = P.Line2D([x], [y], marker='o', ms=5, mec=None, **kwargs) # the artists for the car hs = (hbody, haxle, hleftwheel, hrightwheel, hcenter) # add artists to the axis if supplied if ax: for h in hs: ax.add_artist(h) return hs
def create_artist(self): self.poly = pl.Polygon(self.coordinates, color='k', fill=False) self.artist_list = to_list(self.poly) self.ax.add_artist(self.poly)
pylab.plt.setp(bp['whiskers'], color='g') pylab.plt.setp(bp['medians'], color='black') pylab.plt.setp(bp['fliers'], color=palegreen, marker='+') # Now fill the boxes with desired colors numBoxes = len(plot_data) medians = range(numBoxes) for i in range(numBoxes): box = bp['boxes'][i] boxX = [] boxY = [] for j in range(5): boxX.append(box.get_xdata()[j]) boxY.append(box.get_ydata()[j]) boxCoords = zip(boxX,boxY) boxPolygon = pylab.Polygon(boxCoords, facecolor=palegreen) ax1.add_patch(boxPolygon) # Plot the errors if (len(error_x) > 0): ax1.scatter(error_x, error_y, color='r', marker='x', zorder=3) # Plot throughput ax2 = ax1.twinx() ax2.plot(throughput_data, 'o-', color=paleblue, linewidth=2, markersize=8) # Label the axis ax1.set_title(label) ax1.set_xlabel('Number of concurrent requests') ax2.set_ylabel('Requests per second') ax1.set_ylabel('Milliseconds')
def compAlpha(data, nb_orb=1., t_orb=6283., ciso=1e-3, plot=False \ , save=False): """compAlpha method, to compute Alpha out of \c 'history.txt'. Usage: compAlpha(data, [nb_orb, t_orb, ciso, plot]) With: data: a DumsesHistory object nb_orbit: number of orbits on which to perform the computation t_orb: elapsed time during one orbit (in code unit) ciso: sound speed plot: set to True to plot the results save: set to True to save the plot in PNG, PDF and EPS formats """ try: assert (isinstance(data, dp.DumsesHistory)) except AssertionError: print("Error: 'data' has to be a DumsesHistory object!") sys.exit(42) try: assert ("maxwell" in data.dict) except AssertionError: print(bold + "Error: " + reset + "'maxwell' is not in 'history.txt'") try: assert ("reynolds" in data.dict) except AssertionError: print(bold + "Error: " + reset + "'reynolds' is not in 'history.txt'") try: assert ("max+rey" in data.dict) except AssertionError: print(bold + "Error: " + reset + "'max+rey' is not in 'history.txt'") maxwell = data.dict["maxwell"] reynolds = data.dict["reynolds"] maxnolds = data.dict["max+rey"] if "time" in data.dict: time = data.dict["time"] tmax = time[-1] tlim = nb_orb * t_orb tn = pl.find(time >= (tmax - tlim)) ntn = tn.size xlabel = "time" else: tmax = data.dict.values()[0].size - 1 time = np.linspace(0, tmax, tmax + 1) tlim = tmax - nb_orb tn = map(int, np.linspace(tlim, tmax, nb_orb)) xlabel = r"n$_{\sf hist}$" alpha = np.sum(maxnolds[tn]) / ntn / ciso**2 alpha_max = np.sum(maxwell[tn]) / ntn / ciso**2 alpha_rey = np.sum(reynolds[tn]) / ntn / ciso**2 sigma_alpha = np.sum((maxnolds[tn] / ciso**2 - alpha)**2) / ntn sigma_alpha_max = np.sum((maxwell[tn] / ciso**2 - alpha_max)**2) / ntn sigma_alpha_rey = np.sum((reynolds[tn] / ciso**2 - alpha_rey)**2) / ntn sigma_alpha = np.sqrt(sigma_alpha) sigma_alpha_max = np.sqrt(sigma_alpha_max) sigma_alpha_rey = np.sqrt(sigma_alpha_rey) print("For %d orbits, " %nb_orb + "Alpha = %5.4f" %alpha \ + ' +/- %3.2e' %sigma_alpha) print(" " + "Alpha_Max = %5.4f" %alpha_max \ + ' +/- %3.2e' %sigma_alpha_max) print(" " + "Alpha_Rey = %5.4f" %alpha_rey \ + ' +/- %3.2e' %sigma_alpha_rey) if plot: fig = pl.figure(figsize=(8, 12)) # Alpha total ax = pl.subplot(311) pl.subplots_adjust(bottom=0.15) pl.ylabel(r'$\alpha$') pl.title(r'$\alpha_{\sf mean}$ = %5.4f' %alpha \ + r' $\pm$ %s' %formatter(sigma_alpha)) pl.plot(time / t_orb, maxnolds / ciso**2, color='w') x0, x1, y0, y1 = pl.axis() vert = [((tmax-tlim)/t_orb,y0)] + [((tmax-tlim)/t_orb,y1)] \ + [(x1,y1)] + [(x1,y0)] poly = pl.Polygon(vert, fill=False, edgecolor='grey', hatch='//') ax.add_patch(poly) pl.plot(time / t_orb, maxnolds / ciso**2) pl.plot(time/t_orb \ , pl.linspace(alpha,alpha,time.size) \ , color='k', lw=1.) vert = [(min(time), alpha-sigma_alpha)] \ + [(min(time), alpha+sigma_alpha)] \ + [(x1, alpha+sigma_alpha)] \ + [(x1, alpha-sigma_alpha)] poly = pl.Polygon(vert, facecolor='lightgrey' \ , edgecolor='lightgrey') ax.add_patch(poly) pl.axis([x0, x1, y0, y1]) # Alpha Maxwell ax = pl.subplot(312) pl.subplots_adjust(bottom=0.15) pl.ylabel(r'$\alpha_{\sf Maxwell}$') pl.title(r'$\alpha_{\sf Maxwell\ mean}$ = %5.4f' %alpha_max \ + r' $\pm$ %s' %formatter(sigma_alpha_max)) pl.plot(time / t_orb, maxwell / ciso**2, color='w') x0, x1, y0, y1 = pl.axis() vert = [((tmax-tlim)/t_orb,y0)] + [((tmax-tlim)/t_orb,y1)] \ + [(x1,y1)] + [(x1,y0)] poly = pl.Polygon(vert, fill=False, edgecolor='grey', hatch='//') ax.add_patch(poly) pl.plot(time / t_orb, maxwell / ciso**2) pl.plot(time/t_orb \ , pl.linspace(alpha_max,alpha_max,time.size) \ , color='k', lw=1.) vert = [(min(time), alpha_max-sigma_alpha_max)] \ + [(min(time), alpha_max+sigma_alpha_max)] \ + [(x1, alpha_max+sigma_alpha_max)] \ + [(x1, alpha_max-sigma_alpha_max)] poly = pl.Polygon(vert, facecolor='lightgrey' \ , edgecolor='lightgrey') ax.add_patch(poly) pl.axis([x0, x1, y0, y1]) # Alpha Reynolds ax = pl.subplot(313) pl.subplots_adjust(bottom=0.15) pl.xlabel(xlabel) pl.ylabel(r'$\alpha_{\sf Reynolds}$') pl.title(r'$\alpha_{\sf Reynolds\ mean}$ = %5.4f' %alpha_rey \ + r' $\pm$ %s' %formatter(sigma_alpha_rey)) pl.plot(time / t_orb, reynolds / ciso**2, color='w') x0, x1, y0, y1 = pl.axis() vert = [((tmax-tlim)/t_orb,y0)] + [((tmax-tlim)/t_orb,y1)] \ + [(x1,y1)] + [(x1,y0)] poly = pl.Polygon(vert, fill=False, edgecolor='grey', hatch='//') ax.add_patch(poly) pl.plot(time / t_orb, reynolds / ciso**2) pl.plot(time/t_orb \ , pl.linspace(alpha_rey,alpha_rey,time.size) \ , color='k', lw=1.) vert = [(min(time), alpha_rey-sigma_alpha_rey)] \ + [(min(time), alpha_rey+sigma_alpha_rey)] \ + [(x1, alpha_rey+sigma_alpha_rey)] \ + [(x1, alpha_rey-sigma_alpha_rey)] poly = pl.Polygon(vert, facecolor='lightgrey' \ , edgecolor='lightgrey') ax.add_patch(poly) pl.axis([x0, x1, y0, y1]) if save: for form in ['png', 'pdf', 'eps']: namefig = 'alpha.' + form pl.savefig(namefig) pl.close() else: pl.show()
# ====================================================================== # Return an N-sided polygon in teh shape of an ellipse: # Orientation in degrees. +90 is to account for different definition of # orientation between SExtractor (and IPP?) and pylab. def ellipse((x, y), (a, b), orientation=0, resolution=100, **kwargs): # phi = numpy.deg2rad(orientation+90.0) phi = numpy.deg2rad(orientation) theta = 2 * numpy.pi * pylab.arange(resolution) / resolution xs = a * numpy.cos(theta) ys = b * numpy.sin(theta) xr = x + xs * numpy.cos(phi) - ys * numpy.sin(phi) yr = y + xs * numpy.sin(phi) + ys * numpy.cos(phi) return pylab.Polygon(zip(xr, yr), **kwargs) # ====================================================================== # If called as a script, the python variable __name__ will be set to # "__main__" - so test for this, and execute the main program if so. # Writing it like this allows the function to be called # from the python command line as well as from the unix prompt. if __name__ == '__main__': proto_plot_sources(sys.argv[1:]) # ======================================================================
pyl.figure(figsize=(20, 20), dpi=50) map_axis = pyl.axes([0.0, 0.0, 0.8, 0.9]) cb_axis = pyl.axes([0.83, 0.1, 0.03, 0.6]) c_map = pyl.cm.PuRd pyl.axes(map_axis) pyl.axis([-74.3, -73.6, 40.4, 41.0]) pyl.gca().set_axis_off() for entry in chloro_df.iterrows(): polygon_data = list(zip(*entry[1][1].exterior.coords.xy)) zip_code = entry[1][0] accident_score = entry[1][4] color = c_map(accident_score) patch = pyl.Polygon(polygon_data, facecolor=color, edgecolor=(.3, .3, .3, 1), linewidth=.1) pyl.gca().add_patch(patch) pyl.title('Motor Vehicle Collisions per Zipcode in NYC (2017 - 2018)') max_accidents = chloro_df.accident_score.max() cb = pyl.mpl.colorbar.ColorbarBase(cb_axis, cmap=c_map, norm=pyl.mpl.colors.Normalize( vmin=0, vmax=max_accidents)) cb.set_label('Motor Vehicle Collision Risk Severity (Normalized)') for obj in pyl.gcf().findobj(pyl.matplotlib.text.Text): obj.set_fontname('Arial') obj.set_fontsize(24) pyl.savefig('../output/NYC_MVC_Chloropleth_Map_v2.png')
def draw_static_geo(ax_xy, ax_yz, ax_xz): Np, ro, tfinal, x_lim, y_lim, z_lim, xi_lim, yi_lim, zi_lim = time_pos_ax_limits( ) # Define electrodes poly_cnt = np.array([[-Le / 2, Wg1 / 2], [Le / 2, Wg2 / 2], [Le / 2, -Wg2 / 2], [-Le / 2, -Wg1 / 2]]) poly_top = np.array([[-Le / 2, Wg1 / 2 + Ws + We], [Le / 2, Wg2 / 2 + Ws + We], [Le / 2, Wg2 / 2 + Ws], [-Le / 2, Wg1 / 2 + Ws]]) poly_bottom = np.array([[-Le / 2, -Wg1 / 2 - Ws - We], [Le / 2, -Wg2 / 2 - Ws - We], [Le / 2, -Wg2 / 2 - Ws], [-Le / 2, -Wg1 / 2 - Ws]]) center_electrode = py.Polygon(poly_cnt, closed=True, fc=cl_gold, ec='k') top_electrode = py.Polygon(poly_top, closed=True, fc=cl_gold, ec='k') bottom_electrode = py.Polygon(poly_bottom, closed=True, fc=cl_gold, ec='k') # Draw some fluid walls (not automated yet) # fluid_wall_1_yz = py.Rectangle((-fluid_wall_y, 0), -fluid_wall_yW, fluid_wall_zW, fc=cl_army_green, ec = 'k') # fluid_wall_2_yz = py.Rectangle((fluid_wall_y, 0), fluid_wall_yW, fluid_wall_zW, fc=cl_army_green, ec = 'k') py.gcf().sca(ax_yz) substrate_yz = py.Rectangle((y_lim[0], z_lim[0]), (y_lim[1] - y_lim[0]), abs(z_lim[0]), fc=cl_dgrey, ec='k') py.gca().add_patch(substrate_yz) # py.gca().add_patch(fluid_wall_1_yz) # py.gca().add_patch(fluid_wall_2_yz) py.gcf().sca(ax_xz) substrate_xz = py.Rectangle((x_lim[0], z_lim[0]), (x_lim[1] - x_lim[0]), abs(z_lim[0]), fc=cl_dgrey, ec='k') py.gca().add_patch(substrate_xz) py.gcf().sca(ax_xy) substrate_xy = py.Rectangle((x_lim[0], y_lim[0]), (x_lim[1] - x_lim[0]), (y_lim[1] - y_lim[0]), fc=cl_lgrey) py.gca().add_patch(substrate_xy) py.gca().add_patch(center_electrode) py.gca().add_patch(top_electrode) py.gca().add_patch(bottom_electrode) # Draw fluidic/reflecting geometries w_type = geo_element_types() # Loop over all types of geometry segments for wt in range(w_type.shape[0]): fname = 'geo_points' + str( w_type[wt]) + '()' # name of the corresponding geometry function # Evaluate geo_points*()function by string name p_w, z_w = eval(fname) Nwalls = p_w.shape[0] # Draw all sements of a particular type of geometry for m in range(Nwalls): f_wall_xy = py.Polygon(p_w[m], closed=True, fc=cl_army_green, ec='k') py.gca().add_patch(f_wall_xy) return 0
import numpy as np from scipy import spatial import pylab as pl np.random.seed(42) points2d = np.random.rand(10, 2) ch2d = spatial.ConvexHull(points2d) poly = pl.Polygon(points2d[ch2d.vertices], fill=None, lw=2, color='r', alpha=0.5) ax = pl.subplot(aspect='equal') pl.plot(points2d[:, 0], points2d[:, 1], 'go') for i, pos in enumerate(points2d): pl.text(pos[0], pos[1], str(i), color='blue') ax.add_artist(poly) pl.show()