def add_circular_objects(self, diameters, positions, collision, pause_time=0.1): circ_colors = self.generate_color_array(collision) self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=self.ax.transData, edgecolor='k', facecolor=circ_colors) self.ax.add_collection(self.circles) #add text label text_labels = [None] * len(collision) for i in range(len(collision)): text_labels[i] = plt.text(positions[i, 0], positions[i, 1], str(i), color='k') self.circle_labels = text_labels
class Animator(object): def __init__(self, positions, diameter): self.count = positions.shape[0] plt.ion() fig = plt.figure(figsize=(10, 10)) ax = fig.gca() self.ax = ax diameters = np.ones(self.count) * diameter colors = [randcolor() for _ in range(self.count)] self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=ax.transData, edgecolor='face', facecolor=colors) ax.add_collection(self.circles) ax.axis([0, 1, 0, 1]) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.set_axis_bgcolor('black') plt.draw() def update(self, positions): self.circles.set_offsets(positions) plt.draw()
class Animator(object): def __init__(self, positions, diameter): self.count = positions.shape[0] plt.ion() fig = plt.figure(figsize=(10, 10)) ax = fig.gca() self.ax = ax diameters = np.ones(self.count) * diameter colors = [randcolor() for _ in range(self.count)] self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=ax.transData, edgecolor='face', facecolor=colors) ax.add_collection(self.circles) ax.axis([0, 1, 0, 1]) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.set_axis_bgcolor('black') plt.draw() plt.pause(0.1) #plt.show() #plt.savefig('foo.png') def update(self, positions): self.circles.set_offsets(positions) plt.draw() #plt.show() plt.pause(0.1)
def plot_2d(T): T = np.reshape(T,(n,n,2,2)) x = np.arange(n) y = np.arange(n) Y, X = np.meshgrid(x, y) XY = np.hstack((X.ravel()[:, np.newaxis], Y.ravel()[:, np.newaxis])) ww = T[:,:,0,0]/2.0 hh = T[:,:,1,1]/2.0 aa = T[:,:,0,1]#/1.7 fig, ax = plt.subplots() ec = EllipseCollection(ww, hh,aa*360, units='x', offsets=XY, transOffset=ax.transData) #ec.set_array((X + Y).ravel()) ax.add_collection(ec) ax.autoscale_view() ax.set_xlabel('X') ax.set_ylabel('y') ec.set_facecolor('green') plt.xlim([-1,n]) plt.ylim([-1,n]) #cbar.set_label('X+Y') plt.show() plt.savefig('field.png') np.save('tensor',T)
def scaled_scatter_plot(ax, X, Y, color, radius, filled=True): """ Regular scatter plots require the size of markers to be given in pixels, not relative to the data. This does relative-sized markers. Taken from https://stackoverflow.com/questions/33094509/correct-sizing-of-markers-in-scatter-plot-to-a-radius-r-in-matplotlib. """ offsets = list(zip(X, Y)) size = 2 * radius if filled: ax.add_collection( EllipseCollection(widths=size, heights=size, angles=0, units='xy', facecolors=color, offsets=offsets, transOffset=ax.transData)) else: ax.add_collection( EllipseCollection(widths=size, heights=size, angles=0, units='xy', edgecolors='k', offsets=offsets, transOffset=ax.transData))
def plot_2d(T): T = np.reshape(T, (n, n, 2, 2)) x = np.arange(n) y = np.arange(n) Y, X = np.meshgrid(x, y) XY = np.hstack((X.ravel()[:, np.newaxis], Y.ravel()[:, np.newaxis])) ww = T[:, :, 0, 0] / 2.0 hh = T[:, :, 1, 1] / 2.0 aa = T[:, :, 0, 1] #/1.7 fig, ax = plt.subplots() ec = EllipseCollection(ww, hh, aa * 360, units='x', offsets=XY, transOffset=ax.transData) #ec.set_array((X + Y).ravel()) ax.add_collection(ec) ax.autoscale_view() ax.set_xlabel('X') ax.set_ylabel('y') ec.set_facecolor('green') plt.xlim([-1, n]) plt.ylim([-1, n]) #cbar.set_label('X+Y') plt.show() plt.savefig('field.png') np.save('tensor', T)
def draw_ellipses(w, mu, C, nsigmas=2, color='lightgray', axis=None): """Draw a collection of ellipses. Uses the low-level EllipseCollection to efficiently draw a large number of ellipses. Useful to visualize the results of a GMM fit via GMM_pairplot() defined below. Parameters ---------- w : array 1D array of K relative weights for each ellipse. Must sum to one. Ellipses with smaller weights are rended with greater transparency. mu : array Array of shape (K, 2) giving the 2-dimensional centroids of each ellipse. C : array Array of shape (K, 2, 2) giving the 2 x 2 covariance matrix for each ellipse. axis : matplotlib axis or None Plot axis where the ellipse collection should be drawn. Uses the current default axis when None. """ # Calculate the ellipse angles and bounding boxes using SVD. U, s, _ = np.linalg.svd(C) angles = np.degrees(np.arctan2(U[:, 1, 0], U[:, 0, 0])) widths, heights = 2 * nsigmas * np.sqrt(s.T) # Data limits must already be defined for axis.transData to be valid. axis = axis or plt.gca() axis.add_collection(EllipseCollection( widths, heights, angles, units='xy', offsets=mu, linewidths=4, transOffset=axis.transData, facecolors='none', edgecolors='k')) axis.add_collection(EllipseCollection( widths, heights, angles, units='xy', offsets=mu, linewidths=2.5, transOffset=axis.transData, facecolors='none', edgecolors='w'))
def draw_ellipses(w, mu, C, nsigmas=2, color='red', outline=None, filled=True, axis=None): """Draw a collection of ellipses. Uses the low-level EllipseCollection to efficiently draw a large number of ellipses. Useful to visualize the results of a GMM fit via GMM_pairplot() defined below. Parameters ---------- w : array 1D array of K relative weights for each ellipse. Must sum to one. Ellipses with smaller weights are rendered with greater transparency when filled is True. mu : array Array of shape (K, 2) giving the 2-dimensional centroids of each ellipse. C : array Array of shape (K, 2, 2) giving the 2 x 2 covariance matrix for each ellipse. nsigmas : float Number of sigmas to use for scaling ellipse area to a confidence level. color : matplotlib color spec Color to use for the ellipse edge (and fill when filled is True). outline : None or matplotlib color spec Color to use to outline the ellipse edge, or no outline when None. filled : bool Fill ellipses with color when True, adjusting transparency to indicate relative weights. axis : matplotlib axis or None Plot axis where the ellipse collection should be drawn. Uses the current default axis when None. """ # Calculate the ellipse angles and bounding boxes using SVD. U, s, _ = np.linalg.svd(C) angles = np.degrees(np.arctan2(U[:, 1, 0], U[:, 0, 0])) widths, heights = 2 * nsigmas * np.sqrt(s.T) # Initialize colors. color = colorConverter.to_rgba(color) if filled: # Use transparency to indicate relative weights. ec = np.tile([color], (len(w), 1)) ec[:, -1] *= w fc = np.tile([color], (len(w), 1)) fc[:, -1] *= w ** 2 # Data limits must already be defined for axis.transData to be valid. axis = axis or plt.gca() if outline is not None: axis.add_collection(EllipseCollection( widths, heights, angles, units='xy', offsets=mu, linewidths=4, transOffset=axis.transData, facecolors='none', edgecolors=outline)) if filled: axis.add_collection(EllipseCollection( widths, heights, angles, units='xy', offsets=mu, linewidths=2, transOffset=axis.transData, facecolors=fc, edgecolors=ec)) else: axis.add_collection(EllipseCollection( widths, heights, angles, units='xy', offsets=mu, linewidths=2.5, transOffset=axis.transData, facecolors='none', edgecolors=color))
def plotEllipse(self,barotropic=False,k=0,con='M2',scale=1e4,subsample=4,\ xlims=None,ylims=None,cbarpos=[0.15, 0.15, 0.03, 0.3],**kwargs): """ Plots tidal ellipses on a map """ from matplotlib.collections import EllipseCollection plt.ioff() fig = plt.gcf() ax = fig.gca() iicon = findCon(con,self.frqnames) if self.clim==None: self.clim=[] self.clim.append(np.min(self.Amp)) self.clim.append(np.max(self.Amp)) if xlims==None or ylims==None: xlims=self.xlims ylims=self.ylims ell = self.getEllipse(barotropic=barotropic,k=k,con=con) # Create the ellipse collection indices = range(0,self.Nc,subsample) widths = [ell[0][ii]*scale for ii in indices] heights = [ell[1][ii]*scale for ii in indices] angles = [ell[2][ii]*180.0/np.pi for ii in indices] #angles = [ell[2][ii] for ii in indices] offsets = [(self.xv[ii],self.yv[ii]) for ii in indices] collection = EllipseCollection(widths,heights,angles,units='xy',\ offsets=offsets, transOffset=ax.transData,**kwargs) z=ell[0][indices] collection.set_array(np.array(z)) collection.set_clim(vmin=self.clim[0],vmax=self.clim[1]) collection.set_edgecolors(collection.to_rgba(np.array(z))) ax.set_aspect('equal') ax.set_xlim(xlims) ax.set_ylim(ylims) titlestr='%s - Semi-major Ellipse Amplitude'%(self.frqnames[iicon]) plt.title(titlestr) ax.add_collection(collection) # Add a decent looking colorbar if not cbarpos==None: cbaxes = fig.add_axes(cbarpos) cb = fig.colorbar(collection,cax = cbaxes,orientation='vertical') cb.ax.set_title('[m s$^{-1}$]') plt.sca(ax) #axcb = fig.colorbar(collection) return collection
def plot_as_data(self): """ plot the as data """ if not self.gui.datamanager.hasAS(): return for i in range(len(self.gui.datamanager.datasets['AS'])): data = self.gui.datamanager.datasets['AS'][i].getData() if data is not None: if self.asdata_lines[i] is None: self.asdata_lines[i], = self.as_ax.plot( data[:, 1], data[:, 2], '.', c=cst.ASCOLORS[i % len(cst.ASCOLORS)], ls='', label='Relative position') else: self.asdata_lines[i].set_xdata(data[:, 1]) self.asdata_lines[i].set_ydata(data[:, 2]) if self.as_ellipses[i] is not None: self.as_ellipses[i].remove() self.as_ellipses[i] = EllipseCollection( 2 * data[:, 5], 2 * data[:, 6], data[:, 7] - 90, offsets=np.column_stack((data[:, 1], data[:, 2])), transOffset=self.as_ax.transData, units='x', edgecolors=cst.ASCOLORS[i % len(cst.ASCOLORS)], facecolors=(0, 0, 0, 0)) self.as_ax.add_collection(self.as_ellipses[i])
def draw_confidence_ellipse(self, u, cov, ax, **kwargs): key = (ax, kwargs.pop('key', self.keyfor(u, cov))) fc = kwargs.pop('fc', 'none') ec = kwargs.pop('ec', 'k') zorder = kwargs.pop('zorder', 1) chisquare_val = kwargs.pop( 'scale', 5.991) # 95% confidence area based on chi2(2dof, 0.05) # http://www.visiondummy.com/2014/04/draw-error-ellipse-representing-covariance-matrix/ # https://people.richland.edu/james/lecture/m170/tbl-chi.html if key in self.items: self.items[key].remove() u = np.asarray(u) cov = np.asarray(cov).reshape(-1, 2, 2) widths, heights, angles = self._compute_ellipse_parameters( cov, chisquare_val) e = EllipseCollection(widths, heights, np.degrees(angles), units='y', offsets=u.reshape(2, -1), transOffset=ax.transData, facecolors=fc, edgecolors=ec, zorder=zorder, alpha=0.5) ax.add_collection(e) self.items[key] = e return e,
def save_plot(self, export_path): agent_positions = [agent.position for agent in self.agents] agent_size = [2 * agent.size for agent in self.agents] agent_type_colors = [ self.agent_type_color(agent.type) for agent in self.agents ] agent_status_colors = [ self.agent_status_color(agent.state) for agent in self.agents ] fig, ax = plt.subplots() ax.grid(True) ax.axis(xmin=-25, xmax=self.box[0] + 25, ymin=-25, ymax=self.box[1] + 25) ax.set_aspect(1) points = EllipseCollection(widths=agent_size, heights=agent_size, angles=0, units='xy', linewidths=2, transOffset=ax.transData, alpha=0.3, facecolors=agent_type_colors, edgecolors=agent_status_colors, offsets=agent_positions) ax.add_collection(points) fig.savefig(export_path, dpi=300) plt.close()
def plot(filename, sim, i): fig = plt.figure(i, clear=True, figsize=(10, 10)) xy = sim.get_position() u = sim.get_orientation() sigma_s = sim.get_sigma_s() k = sim.get_k() n = sim.size() ww = np.ones(n)*sigma_s*k hh = np.ones(n)*sigma_s aa = np.arctan2(u[:, 1], u[:, 0])*360/(2*3.14) ax = fig.subplots() ec = EllipseCollection(ww, hh, aa, units='x', offsets=xy, transOffset=ax.transData) ax.add_collection(ec) ax.autoscale_view() ax.quiver(xy[:, 0], xy[:, 1], u[:, 0], u[:, 1]) ax.set_xlabel('X') ax.set_ylabel('y') ax.set_xlim(-2, 2) ax.set_ylim(-2, 2) ax.set_title('job %d' % i) fig.savefig(filename+'.png') plt.close(fig) data = np.concatenate([xy, u], axis=1) np.savetxt(filename+'.csv', data, header='x y ux uy')
def plot_multi(filename, sims): fig, axs = plt.subplots(1, len(sims), clear=True, figsize=(12, 4)) for i, sim in enumerate(sims): xy = sim.get_position() u = sim.get_orientation() sigma_s = sim.get_sigma_s() k = sim.get_k() n = sim.size() ww = np.ones(n)*sigma_s*k hh = np.ones(n)*sigma_s aa = np.arctan2(u[:, 1], u[:, 0])*360/(2*3.14) ax = axs[i] ec = EllipseCollection(ww, hh, aa, units='x', offsets=xy, transOffset=ax.transData) ax.add_collection(ec) ax.autoscale_view() ax.quiver(xy[:, 0], xy[:, 1], u[:, 0], u[:, 1]) ax.set_xlabel('X') ax.set_ylabel('y') ax.set_xlim(-2, 2) ax.set_ylim(-2, 2) axs[0].set_title('weak support\npotential well scaling = %d' % params[0].potential_well_scaling) axs[1].set_title('medium support\npotential well scaling = %d' % params[1].potential_well_scaling) axs[2].set_title('strong support\npotential well scaling = %d' % params[2].potential_well_scaling) fig.savefig(filename)
def plot_corr_ellipses(data, ax=None, **kwargs): M = np.array(data) if not M.ndim == 2: raise ValueError('data must be a 2D array') if ax is None: fig, ax = plt.subplots(1, 1, subplot_kw={'aspect':'equal'}) ax.set_xlim(-0.5, M.shape[1] - 0.5) ax.set_ylim(-0.5, M.shape[0] - 0.5) # xy locations of each ellipse center xy = np.indices(M.shape)[::-1].reshape(2, -1).T # set the relative sizes of the major/minor axes according to the strength of # the positive/negative correlation w = np.ones_like(M).ravel() h = 1 - np.abs(M).ravel() a = 45 * np.sign(M).ravel() ec = EllipseCollection(widths=w, heights=h, angles=a, units='x', offsets=xy, transOffset=ax.transData, array=M.ravel(), **kwargs) ax.add_collection(ec) # if data is a DataFrame, use the row/column names as tick labels if isinstance(data, pd.DataFrame): ax.set_xticks(np.arange(M.shape[1])) ax.set_xticklabels(data.columns, rotation=90) ax.set_yticks(np.arange(M.shape[0])) ax.set_yticklabels(data.index) return ec
def plot_spiral(self, axis, true, data, obsv, pred, rng): """Plots a single spiral on provided axis.""" axis.cla() # Plot 95% confidence ellipses ec = EllipseCollection(1.96 * rng[0], 1.96 * rng[1], (0, ), units='x', facecolors=('c', ), alpha=0.25, offsets=np.column_stack(pred), transOffset=axis.transData) axis.add_collection(ec) # Plot ground truth axis.plot(true[0], true[1], 'b-', linewidth=1.5) # Plot observations (blue = both, pink = x-only, yellow = y-only) if (np.isnan(obsv[0]) != np.isnan(obsv[1])).any(): axis.plot(obsv[0], data[1], '<', markersize=2, color='#fe46a5') axis.plot(data[0], obsv[1], 'v', markersize=2, color='#fec615') axis.plot(obsv[0], obsv[1], 'bo', markersize=3) # Plot predictions axis.plot(pred[0], pred[1], '-', linewidth=1.5, color='#04d8b2') # Set limits axis.set_xlim(-4, 4) axis.set_ylim(-4, 4)
def plot_corr_ellipses(data, ax=None, **kwargs): M = np.array(data) if not M.ndim == 2: raise ValueError('data must be a 2D array') if ax is None: fig, ax = plt.subplots(1, 1, subplot_kw={'aspect': 'equal'}) ax.set_xlim(-0.5, M.shape[1] - 0.5) ax.set_ylim(-0.5, M.shape[0] - 0.5) # xy locations of each ellipse center xy = np.indices(M.shape)[::-1].reshape(2, -1).T x, y = zip(*xy) x = np.array(x, dtype=np.int8) y = np.array(y, dtype=np.int8) ind = x <= y # set the relative sizes of the major/minor axes according to the strength of # the positive/negative correlation w = np.ones_like(M).ravel() h = 1 - np.abs(M).ravel() w *= 0.85 h *= 0.85 a = 45 * np.sign(M).ravel() w = w[ind] h = h[ind] a = a[ind] xymat = xy[ind] Mfull = M.ravel() Mhalf = Mfull[ind] linewidths = np.repeat(1 + np.abs(Mhalf), len(h)) edgecolors = cm.binary(np.abs(Mhalf)) ec = EllipseCollection(widths=w, heights=h, angles=a, units='x', offsets=xymat, linewidths=linewidths, edgecolors=edgecolors, transOffset=ax.transData, array=Mhalf, **kwargs) ax.add_collection(ec) for xt, yt, val in zip(x[~ind], y[~ind], Mfull[~ind]): strval = '{:+.2f}'.format(val).replace('0.', '.') ax.text(xt, yt, strval, ha='center', va='baseline', fontsize='small') # if data is a DataFrame, use the row/column names as tick labels if isinstance(data, pd.DataFrame): ax.set_xticks(np.arange(M.shape[1])) ax.set_xticklabels(data.columns, rotation=30) ax.set_yticks(np.arange(M.shape[0])) ax.set_yticklabels(data.index, rotation=30) ax.set_xlim(x.min() - 0.5, x.max() + 0.5) ax.set_ylim(x.min() - 0.5, x.max() + 0.5) ax.set_aspect('equal') return ec
def update(self, positions): #update number of balls self.circles.set_offsets(positions) colors = [(1.0, 0.0, 0.0) for _ in range(self.circ_count)] self.circles.set_facecolors(colors) #redefine circles diameter = 2 diameters = np.ones(self.circ_count + 100) * diameter circ_colors = [(0.0, 0.0, 1.0) for _ in range(self.circ_count)] #add circles self.circles.remove() self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=self.ax.transData, edgecolor='face', facecolor=circ_colors) self.ax.add_collection(self.circles) #label text_labels = [None] * positions.shape[0] for i in range(positions.shape[0]): text_labels[i] = plt.text(positions[i, 0], positions[i, 1], str(i), color='white') #remove polygon #self.polygons.remove() poly_color = np.random.uniform(0.0, 0.89, (3, )) + 0.1 verts = [[(10, 1), (9, 0), (8, 2), (10, 2)], [(8, 8), (9, 9), (6, 7)]] self.polygons.set_verts(verts) plt.draw() plt.pause(0.1) #remove labels for i in range(positions.shape[0]): text_labels[i].remove()
def __init__(self, **kwargs): super(HoughDemo, self).__init__(**kwargs) self.connect_dirty("th2, show_canny, show_blur, rho, theta, hough_th," "min_radius, max_radius, blur_sigma," "minlen, maxgap, dp, mindist, param2, " "linewidth, alpha, check_line, check_circle") self.lines = LineCollection([], linewidths=2, alpha=0.6) self.axe.add_collection(self.lines) self.circles = EllipseCollection([], [], [], units="xy", facecolors="none", edgecolors="red", linewidths=2, alpha=0.6, transOffset=self.axe.transData) self.axe.add_collection(self.circles)
def overlay_fibers(self, ax, diameter=None, skies=None, return_figure=True, **kwargs): """ Overlay the individual fibers within an IFU on a plot. Parameters: ax (Axis): The matplotlib axis object diameter (float): The fiber diameter in arcsec. Default is 2". skies (bool): Set to True to additionally overlay the sky fibers. Default if False return_figure (bool): If True, returns the figure axis object. Default is True kwargs: Any keyword arguments accepted by Matplotlib EllipseCollection """ if self.wcs is None: raise MarvinError('No WCS found. Cannot overlay fibers.') # check the diameter if diameter: assert isinstance(diameter, (float, int)), 'diameter must be a number' diameter = (diameter or 2.0) / float(self.header['SCALE']) # get the fiber pixel coordinates fibers = self.bundle.fibers[:, [1, 2]] fiber_pix = self.wcs.wcs_world2pix(fibers, 1) # some matplotlib kwargs kwargs['edgecolor'] = kwargs.get('edgecolor', 'Orange') kwargs['facecolor'] = kwargs.get('facecolor', 'none') kwargs['linewidth'] = kwargs.get('linewidth', 0.4) ec = EllipseCollection(diameter, diameter, 0.0, units='xy', offsets=fiber_pix, transOffset=ax.transData, **kwargs) ax.add_collection(ec) # overlay the sky fibers if skies: self.overlay_skies(ax, diameter=diameter, return_figure=return_figure, **kwargs) if return_figure: return ax
def ellipse_plot(self, ax=None, **kwargs): """ Make an ellipse plot of the correlation matrix. Return the figure instance. Code modified from https://stackoverflow.com/a/34558488/787267 :param ax: If specified, will plot in this axes instance, otherwise will create a new figure instance :param kwargs: Key word arguments to be passed to matplotlib.collections.EllipseCollection. The default clim is [-1,1], use clim=None if the color scaling is to be set automatically :return: A matplotlotlib.pyplot.figure instance """ M = self.matrix.values if ax is None: fig, ax = plt.subplots(1, 1, subplot_kw={'aspect': 'equal'}) ax.set_xlim(-0.5, M.shape[1] - 0.5) ax.set_ylim(-0.5, M.shape[0] - 0.5) ax.margins(0.1) # xy locations of each ellipse center xy = np.indices(M.shape).reshape(2, -1).T # set the relative sizes of the major/minor axes according to the strength of # the positive/negative correlation w = np.ones_like(M).ravel() h = 1 - np.abs(M).ravel() # Fix diagonal entries to be straight lines h = [0.01 if e == 0 else e for e in h] a = 45 * np.sign(M).ravel() kwargs.setdefault('cmap', 'bwr_r') kwargs.setdefault('clim', [-1, 1]) ec = EllipseCollection(widths=w, heights=h, angles=a, units='x', offsets=xy, transOffset=ax.transData, array=M.ravel(), **kwargs) ax.add_collection(ec) for x, y in xy: ax.annotate("%.1f" % M[x, y], xy=(x, y), va='center', ha='center') cb = fig.colorbar(ec) cb.set_label('Correlation coefficient') ax.set_xticks(np.arange(self.matrix.shape[1])) ax.set_xticklabels(self.columns) ax.set_yticks(np.arange(self.matrix.shape[0])) ax.set_yticklabels(self.rows) ax.invert_yaxis() ax.xaxis.tick_top() return ec.figure
def error_ellipse(x, y, xerr, yerr, alpha=0.2, **kw): """Like errorbar, but uses ellipses""" from matplotlib.collections import EllipseCollection ax = plt.gca() ec = EllipseCollection(xerr, yerr, 0, units='xy', offsets=np.asarray([x, y]).T, transOffset=ax.transData, alpha=alpha, **kw) ax.add_collection(ec) return ec
def ellipse_collection(self, x, y, widths, heights, angles, cvalues=None, **kwargs): import numpy as np from interactive_plotter.interactive_artist import EllipseCollection from matplotlib.collections import EllipseCollection as __EllipseCollection artist = __EllipseCollection([0] * x.size, [0] * x.size, [0] * x.size, offsets=np.zeros((x.size, 2)), transOffset=self.__axes.transData, **kwargs) self.__axes.add_collection(artist) interactive_artist = EllipseCollection(artist) interactive_artist.plot(x, y, widths, heights, angles, cvalues) self.__add_foreground_artist(interactive_artist) return interactive_artist
def _plot_listeners(ls_xys, ax): if isinstance(ls_xys, (list,)): ls_xys = np.array(ls_xys) size = np.full(ls_xys.shape[0], 2 * DSRC_RANGE) wifi = EllipseCollection(widths=size, heights=size, angles=0, units='xy', offsets=ls_xys, transOffset=ax.transData, color='white', edgecolor='black', linestyle='--', zorder=2) ax.add_collection(wifi) size = np.full(ls_xys.shape[0], 2 * WIFI_RANGE) dsrc = EllipseCollection(widths=size, heights=size, angles=0, units='xy', offsets=ls_xys, transOffset=ax.transData, color='white', edgecolor='black', linestyle='-', zorder=2) ax.add_collection(dsrc) # make sure the points show up in the legend ax.scatter([], [], color='white', s=21, edgecolor='black', linestyle='--', label='DSRC coverage') ax.scatter([], [], color='white', s=7, edgecolor='black', linestyle='-', label='WiFi coverage') ax.axis('equal') return ax
def update(kk): ellipseNode = NodeList[kk] ellNodeShape = ellipseNode.means.shape xPlotValues = [] yPlotValues = [] xValues = [] yValues = [] widthValues = [] heightValues = [] angleValues = [] # Prepare the trajectory x and y vectors and plot them for k in range(ellNodeShape[0]): xPlotValues.append(ellipseNode.means[k, 0, 0]) yPlotValues.append(ellipseNode.means[k, 1, 0]) # Plotting the risk bounded trajectories lx, = plt.plot(xPlotValues, yPlotValues, "#636D97", linewidth=2.0) # Plot only the last ellipse in the trajectory alfa = math.atan2(ellipseNode.means[-1, 1, 0], ellipseNode.means[-1, 0, 0]) elcovar = np.asarray(ellipseNode.covar[-1, :, :]) elE, elV = LA.eig(elcovar[0:2, 0:2]) xValues.append(ellipseNode.means[-1, 0, 0]) yValues.append(ellipseNode.means[-1, 1, 0]) widthValues.append(math.sqrt(elE[0])) heightValues.append(math.sqrt(elE[1])) angleValues.append(alfa * 360) # Plot the Safe Ellipses XY = np.column_stack((xValues, yValues)) ec = EllipseCollection(widthValues, heightValues, angleValues, units='x', offsets=XY, facecolors="#C59434", transOffset=plt.axes().transData) ec.set_alpha(0.5) plt.axes().add_collection(ec) return lx, ec
def _update_ellipsoids(self, su, sv, rho): self.scale_units = 'xy' self.angles = 'xy' tips_x = self.X + self.U / self.scale tips_y = self.Y + self.V / self.scale tips = np.array([tips_x, tips_y]).transpose() a, b, angle = compute_abphi(su, sv, rho) width = 2.0 * a / self.scale height = 2.0 * b / self.scale if self.ellipsoids is not None: self.ellipsoids.remove() # do not draw ellipses which are too small too_small = 0.001 length = np.sqrt((self.U / self.scale)**2 + (self.V / self.scale)**2) with warnings.catch_warnings(): # do not print out zero division warning warnings.simplefilter("ignore") is_not_too_small = ((np.nan_to_num(width / length) > too_small) | (np.nan_to_num(height / length) > too_small)) width = width[is_not_too_small] height = height[is_not_too_small] angle = angle[is_not_too_small] tips = tips[is_not_too_small] # dont add ellipses if there are no ellipses to add if any(is_not_too_small): self.ellipsoids = EllipseCollection(width, height, angle, units=self.scale_units, offsets=tips, transOffset=self.ax.transData, **self.ellipse_kwargs) self.ax.add_collection(self.ellipsoids) else: self.ellipsoids = None
def circular_border(ax): offsets = [width / 2, height / 2] color = 'k' size = width - 10 ax.add_collection( EllipseCollection(widths=size, heights=size, angles=0, units='xy', facecolors='w', edgecolors='k', offsets=offsets, transOffset=ax.transData))
def plot_spd2(Is, filename=None): rc('axes', linewidth=0.5) rc('font', size=7, family='serif') rc('xtick', top=True, direction='in') rc('xtick.major', size=2.5, width=0.5) rc('ytick', right=True, direction='in') rc('ytick.major', size=2.5, width=0.5) fig = plt.figure(figsize=(len(Is) * 5, 5), dpi=100) for k, I in enumerate(Is): ax = fig.add_subplot(100 + len(Is) * 10 + (k + 1)) imagedims = I.shape[:2] vals, vecs = np.linalg.eig(I) FA = np.sqrt(0.5 * (vals[..., 0]**2 + vals[..., 1]**2) - vals[..., 0] * vals[..., 1]) FA /= np.linalg.norm(Is[0], axis=(-2, -1)) lvals = np.log(vals) GA = np.sqrt(0.5 * (lvals[..., 0]**2 + lvals[..., 1]**2) - lvals[..., 0] * lvals[..., 1]) GA /= 1 + GA angles = 180 + 180 * np.arctan2(vecs[..., 0, 0], vecs[..., 1, 0]) / np.pi vals /= 0.5 * vals.max() X, Y = np.meshgrid(np.arange(imagedims[0]), np.arange(imagedims[1])) XY = np.vstack((X.ravel(), Y.ravel())).T ec = EllipseCollection(vals[..., 0], vals[..., 1], angles, units='x', offsets=XY, transOffset=ax.transData, edgecolors=0.8 * cm.hsv(GA.ravel())[:, :-1], facecolors=1.0 * cm.hsv(GA.ravel())[:, :-1], linewidths=0.5) ax.add_collection(ec) ax.autoscale_view() ax.invert_yaxis() ax.axis("equal") if filename is None: plt.show() else: canvas = FigureCanvasAgg(fig) canvas.print_figure(filename) plt.close(fig)
def __init__(self, positions, diameter): self.circ_count = positions.shape[0] plt.ion() fig = plt.figure(figsize=(10, 10)) ax = fig.gca() self.ax = ax diameters = np.ones(self.circ_count) * diameter circ_colors = [(0.0, 0.0, 1.0) for _ in range(self.circ_count)] #add circles self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=ax.transData, edgecolor='face', facecolor=circ_colors) ax.add_collection(self.circles) #add polygons self.poly_count = 3 verts = [[(0, 1), (1, 0), (2, 2)], [(6, 5), (3, 7), (7, 6)], [(0, -1), (-1, 0), (4, 5)]] poly_colors = [(0.0, 0.0, 1.0) for _ in range(self.poly_count)] self.polygons = PolyCollection(verts, facecolors=poly_colors) ax.add_collection(self.polygons) ax.axis([-20, 20, -20, 20]) ax.get_xaxis().set_visible(True) ax.get_yaxis().set_visible(True) #ax.set_axis_bgcolor('black') plt.draw() plt.pause(0.1)
def plot_corr_ellipses(data, ax=None, **kwargs): """For a given correlation matrix "data", plot the correlation matrix in terms of ellipses. parameters ---------- data: Pandas dataframe containing the correlation of the data (df.corr()) ax: axis (e.g. fig, ax = plt.subplots(1, 1)) kwards: keywords arguments (cmap="Greens") https://stackoverflow.com/questions/34556180/ how-can-i-plot-a-correlation-matrix-as-a-set-of-ellipses-similar-to-the-r-open """ M = np.array(data) if not M.ndim == 2: raise ValueError('data must be a 2D array') if ax is None: fig, ax = plt.subplots(1, 1, subplot_kw={'aspect': 'equal'}) ax.set_xlim(-0.5, M.shape[1] - 0.5) ax.set_ylim(-0.5, M.shape[0] - 0.5) # xy locations of each ellipse center xy = np.indices(M.shape)[::-1].reshape(2, -1).T # set the relative sizes of the major/minor axes according to the strength of # the positive/negative correlation w = np.ones_like(M).ravel() h = 1 - np.abs(M).ravel() a = 45 * np.sign(M).ravel() ec = EllipseCollection(widths=w, heights=h, angles=a, units='x', offsets=xy, transOffset=ax.transData, array=M.ravel(), **kwargs) ax.add_collection(ec) # if data is a DataFrame, use the row/column names as tick labels if isinstance(data, pd.DataFrame): ax.set_xticks(np.arange(M.shape[1])) ax.set_xticklabels(data.columns, rotation=90) ax.set_yticks(np.arange(M.shape[0])) ax.set_yticklabels(data.index) return ec
def DrawGraph(self, lastFlag, randNode=None): """ Updates the Plot with uncertainty ellipse and trajectory at each time step Input Parameters: lastFlag: Flag to denote if its the last iteration randNode: Node data representing the randomly sampled point """ xValues = [] yValues = [] widthValues = [] heightValues = [] angleValues = [] lineObjects = [] for ellipseNode in self.nodeList: if ellipseNode is not None and ellipseNode.parent is not None: ellNodeShape = ellipseNode.means.shape xPlotValues = [] yPlotValues = [] # Prepare the trajectory x and y vectors and plot them for k in range(ellNodeShape[0]): xPlotValues.append(ellipseNode.means[k,0,0]) yPlotValues.append(ellipseNode.means[k,1,0]) # Plotting the risk bounded trajectories lx, = plt.plot(xPlotValues, yPlotValues, "#636D97", linewidth=2.0) lineObjects.append(lx) # Plot only the last ellipse in the trajectory alfa = math.atan2(ellipseNode.means[-1,1,0], ellipseNode.means[-1,0,0]) elcovar = np.asarray(ellipseNode.covar[-1,:,:]) elE, elV = LA.eig(elcovar[0:2,0:2]) xValues.append(ellipseNode.means[-1,0,0]) yValues.append(ellipseNode.means[-1,1,0]) widthValues.append(math.sqrt(elE[0])) heightValues.append(math.sqrt(elE[1])) angleValues.append(alfa*360) # Plot the randomly sampled point rx, = plt.plot(randNode.means[-1,0,:], randNode.means[-1,1,:], "^k") # Plot the Safe Ellipses XY = np.column_stack((xValues, yValues)) ec = EllipseCollection(widthValues, heightValues, angleValues, units='x', offsets=XY, facecolors="#C59434", transOffset=plt.axes().transData) ec.set_alpha(0.5) plt.axes().add_collection(ec) plt.pause(0.0001) if not lastFlag: ec.remove() rx.remove() for lx in lineObjects: lx.remove()
def circle(self, x, y, dira, a, b, ax=None, **kwargs): """ Draw Ellipses with dira as primary axis, a, b as axis half length at x, y""" if ax is None: ax = self.default_axes dira = numpy.atleast_2d(dira) col = EllipseCollection(offsets=numpy.array([x, y]).T, widths=a, heights=b, units='xy', transOffset=ax.transData, angles=numpy.arctan2(dira[:, 1], dira[:, 0]) / numpy.pi * 180, **kwargs) ax.add_collection(col) ax.autoscale_view() return col
def __init__(self, **kwargs): super(HoughDemo, self).__init__(**kwargs) self.connect_dirty("th2, show_canny, show_blur, rho, theta, hough_th," "min_radius, max_radius, blur_sigma," "minlen, maxgap, dp, mindist, param2, " "linewidth, alpha, check_line, check_circle") self.lines = LineCollection([], linewidths=2, alpha=0.6) self.axe.add_collection(self.lines) self.circles = EllipseCollection( [], [], [], units="xy", facecolors="none", edgecolors="red", linewidths=2, alpha=0.6, transOffset=self.axe.transData) self.axe.add_collection(self.circles)
def add_circular_objects(self,diameters,positions,collision,pause_time=0.1): circ_colors = self.generate_color_array(collision) self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=self.ax.transData, edgecolor='k', facecolor=circ_colors) self.ax.add_collection(self.circles) #add text label text_labels = [None] * len(collision) for i in range(len(collision)): text_labels[i]= plt.text(positions[i,0],positions[i,1],str(i),color = 'k') self.circle_labels = text_labels
def _update_ellipsoids(self,su,sv,rho): self.scale_units = 'xy' self.angles = 'xy' tips_x = self.X + self.U/self.scale tips_y = self.Y + self.V/self.scale tips = np.array([tips_x,tips_y]).transpose() a,b,angle = compute_abphi(su,sv,rho) width = 2.0*a/self.scale height = 2.0*b/self.scale if self.ellipsoids is not None: self.ellipsoids.remove() # do not draw ellipses which are too small too_small = 0.001 length = np.sqrt((self.U/self.scale)**2 + (self.V/self.scale)**2) with warnings.catch_warnings(): # do not print out zero division warning warnings.simplefilter("ignore") is_not_too_small = ((np.nan_to_num(width/length) > too_small) | (np.nan_to_num(height/length) > too_small)) width = width[is_not_too_small] height = height[is_not_too_small] angle = angle[is_not_too_small] tips = tips[is_not_too_small] # dont add ellipses if there are no ellipses to add if any(is_not_too_small): self.ellipsoids = EllipseCollection(width,height,angle, units=self.scale_units, offsets = tips, transOffset=self.ax.transData, **self.ellipse_kwargs) self.ax.add_collection(self.ellipsoids) else: self.ellipsoids = None
def __init__(self, positions, diameter): self.count = positions.shape[0] plt.ion() fig = plt.figure(figsize=(10, 10)) ax = fig.gca() self.ax = ax diameters = np.ones(self.count) * diameter self.colors = np.array([randcolor() for _ in range(self.count)]) self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=ax.transData, edgecolor='face', facecolor=self.colors) ax.add_collection(self.circles) ax.axis([0, 1, 0, 1]) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.set_axis_bgcolor('black') plt.draw()
def graph(locator, parameters, method, samples): """ :param locator: locator class :param parameters: list of output parameters to analyse :param method: 'morris' or 'sobol' methods :param samples: number of samples to calculate :return: .pdf file per output_parameter stored in locator.get_sensitivity_plots_file() """ if method is 'sobol': result = ['ST', 'conf', 'S1'] else: result = ['mu_star', 'sigma', 'mu_star_conf'] for parameter in parameters: pdf = PdfPages(locator.get_sensitivity_plots_file(parameter)) # read the mustar of morris analysis data_mu = pd.read_excel(locator.get_sensitivity_output(method, samples), (parameter + result[0])) data_sigma = pd.read_excel(locator.get_sensitivity_output(method, samples), (parameter + result[1])) var_names = data_mu.columns.values # normalize data to maximum value data_mu[var_names] = data_mu[var_names].div(data_mu[var_names].max(axis=1), axis=0) data_sigma[var_names] = data_sigma[var_names].div(data_sigma[var_names].max(axis=1), axis=0) # get x_names and y_names # columns x_names = data_mu.columns.tolist() # rows y_names = ['config '+str(i) for i in list(data_mu.index+1)] # get counter (integer to create the graph) x = range(len(x_names)) y = range(len (y_names)) X, Y = np.meshgrid(x,y) XY = np.hstack((X.ravel()[:, np.newaxis], Y.ravel()[:, np.newaxis])) ww = data_mu.values.tolist() hh = data_sigma.values.tolist() aa = X*0 fig, ax = plt.subplots(dpi=150, figsize=(len(x_names)+2, len(y_names)+2)) # ec = EllipseCollection(ww, hh, aa, units='x', offsets=XY, transOffset=ax.transData, cmap='Blues') ec.set_array(np.array(ww).ravel()) ec.set_alpha(0.8) ax.add_collection(ec) ax.autoscale_view() plt.xticks(np.arange(-1, max(x) + 1, 1.0)) plt.yticks(np.arange(-1, max(y) + 1, 1.0)) ax.set_xlabel('variables [-]') ax.set_ylabel('configurations [-]') ax.set_xticklabels([""]+x_names) ax.set_yticklabels([""]+y_names) cbar = plt.colorbar(ec) cbar.set_label(result[0]) plt.title('GRAPH OF '+parameter+' PARAMETER', fontsize=14, fontstyle='italic', fontweight='bold') pdf.savefig() plt.close() plt.clf() pdf.close()
class Quiver(_Quiver): def __init__(self,ax,*args,**kwargs): if 'sigma' in kwargs: scale_units = kwargs.get('scale_units','xy') kwargs['scale_units'] = scale_units if kwargs['scale_units'] != 'xy': raise ValueError('scale units must be "xy" when sigma is given') angles = kwargs.get('angles','xy') kwargs['angles'] = angles if kwargs['angles'] != 'xy': raise ValueError('angles must be "xy" when sigma is given') sigma = kwargs.pop('sigma',None) ellipse_kwargs = kwargs.pop('ellipse_kwargs',{}) if 'offsets' in ellipse_kwargs: raise ValueError('cannot specify ellipse offsets') if 'units' in ellipse_kwargs: raise ValueError('cannot specify ellipse units') self.ellipse_kwargs = {'edgecolors':'k', 'facecolors':'none', 'linewidths':1.0} self.ellipse_kwargs.update(ellipse_kwargs) self.ellipsoids = None _Quiver.__init__(self,ax,*args,**kwargs) if sigma is not None: if self.scale is None: self.scale = _estimate_scale(self.X,self.Y,self.U,self.V) su,sv,rho = sigma[0],sigma[1],sigma[2] self._update_ellipsoids(su,sv,rho) def _update_ellipsoids(self,su,sv,rho): self.scale_units = 'xy' self.angles = 'xy' tips_x = self.X + self.U/self.scale tips_y = self.Y + self.V/self.scale tips = np.array([tips_x,tips_y]).transpose() a,b,angle = compute_abphi(su,sv,rho) width = 2.0*a/self.scale height = 2.0*b/self.scale if self.ellipsoids is not None: self.ellipsoids.remove() # do not draw ellipses which are too small too_small = 0.001 length = np.sqrt((self.U/self.scale)**2 + (self.V/self.scale)**2) with warnings.catch_warnings(): # do not print out zero division warning warnings.simplefilter("ignore") is_not_too_small = ((np.nan_to_num(width/length) > too_small) | (np.nan_to_num(height/length) > too_small)) width = width[is_not_too_small] height = height[is_not_too_small] angle = angle[is_not_too_small] tips = tips[is_not_too_small] # dont add ellipses if there are no ellipses to add if any(is_not_too_small): self.ellipsoids = EllipseCollection(width,height,angle, units=self.scale_units, offsets = tips, transOffset=self.ax.transData, **self.ellipse_kwargs) self.ax.add_collection(self.ellipsoids) else: self.ellipsoids = None def set_UVC(self,u,v,C=None,sigma=None): if C is None: _Quiver.set_UVC(self,u,v) else: _Quiver.set_UVC(self,u,v,C) if sigma is not None: su,sv,rho = sigma[0],sigma[1],sigma[2] self._update_ellipsoids(su,sv,rho) def remove(self): # remove the quiver and ellipsoid collection _Quiver.remove(self) if self.ellipsoids is not None: self.ellipsoids.remove()
class Animator(object): def __init__(self, template_w, template_h): #set up figure plt.ion() fig = plt.figure(figsize = (10,10)) ax = fig.gca() ax.axis([-template_w/2.0, template_w/2.0,-template_h/2.0,template_h/2.0]) ax.get_xaxis().set_visible(True) ax.get_yaxis().set_visible(True) #draw template self.plot_template(template_w,template_h) #draw to screen plt.draw() plt.pause(0.1) #save axes to object self.ax = ax #plot template def plot_template(self,l = 20.0, w = 20.0): x_pos = [-l/2, l/2, l/2, -l/2, -l/2 ] y_pos = [-w/2, -w/2, w/2, w/2, -w/2] plt.plot(x_pos,y_pos,'k-',linewidth = 3.0) plt.xlabel('x') plt.ylabel('y') def generate_color_array(self,collision): #define colors (red = collision, blue = no collision) colors = [None] * len(collision) for i in range(len(collision)): if collision[i] == True: colors[i] = (1.0,0.0,0.0) else: colors[i] = (0.0,0.0,1.0) return colors #add circular objects def add_circular_objects(self,diameters,positions,collision): circ_colors = self.generate_color_array(collision) self.circles = EllipseCollection(widths=diameters, heights=diameters, angles=np.zeros_like(diameters), units='xy', offsets=positions, transOffset=self.ax.transData, edgecolor='k', facecolor=circ_colors) self.ax.add_collection(self.circles) #add text label text_labels = [None] * len(collision) for i in range(len(collision)): text_labels[i]= plt.text(positions[i,0],positions[i,1],str(i),color = 'w') self.circle_labels = text_labels #draw to screen plt.draw() plt.pause(0.1) #remove text labels #for i in range(len(collision)): # text_labels[i].remove() #add polygon objects def add_polygon_objects(self,verts,collision): poly_colors = self.generate_color_array(collision) self.polygons = PolyCollection(verts, facecolors=poly_colors) self.ax.add_collection(self.polygons) #add text label num_circles = self.circles.get_offsets().shape[1] text_labels = [None] * len(collision) for i in range(len(collision)): temp = np.array(verts[i]) x = np.mean(temp[:,0]) y = np.mean(temp[:,1]) text_labels[i]= plt.text(x,y,str(i+num_circles),color = 'w') self.polygon_labels = text_labels plt.draw() plt.pause(0.1) #remove text labels #for i in range(len(collision)): # text_labels[i].remove() #remove circular objects: def remove_circles(self): self.circles.remove() for label in self.circle_labels: label.remove() #remove polygon objects: def remove_polygons(self): self.polygons.remove() for label in self.polygon_labels: label.remove() #update circular objects def update_circular_objects(self,positions,collision): #set circle colors circ_colors = self.generate_color_array(collision) self.circles.set_facecolors(circ_colors) #set circle positions self.circles.set_offsets(positions) #remove labels for label in self.circle_labels: label.remove() #add labels text_labels = [None] * len(collision) for i in range(len(collision)): text_labels[i]= plt.text(positions[i,0],positions[i,1],str(i),color = 'w') self.circle_labels = text_labels plt.draw() plt.pause(0.1) #update polygon objects def update_polygon_objects(self,positions,collision): #set polygon colors poly_colors = self.generate_color_array(collision) self.polygons.set_facecolors(poly_colors) #set polygon positions #print 'new verts positions=' , positions self.polygons.set_verts(positions) #remove labels for label in self.polygon_labels: label.remove() #add new labels num_circles = self.circles.get_offsets().shape[1] #print self.polygons.get_offsets() #assert(0) text_labels = [None] * len(collision) for i in range(len(collision)): temp = np.array(positions[i]) x = np.mean(temp[:,0]) y = np.mean(temp[:,1]) text_labels[i]= plt.text(x,y,str(i+num_circles),color = 'w') self.polygon_labels = text_labels plt.draw() plt.pause(0.1)
homey = np.hstack((X.ravel()[:,np.newaxis], Y.ravel()[:,np.newaxis])) ww = X/10.0 ww[:] = 1.0 hh = Y/15.0 hh[:] = 0.333 aa = X*9 #aa[:] = -50.0 fig, ax = plt.subplots() myalpha = ww myalpha[:] = 0.5 ec = EllipseCollection( ww, hh, aa, units='x', alpha = 0.1, offsets=homey, transOffset=ax.transData) simon = (X+Y).ravel() ec.set_array(simon) ax.add_collection(ec) ax.autoscale_view() ax.set_xlabel('X') ax.set_ylabel('y') cbar = plt.colorbar(ec) cbar.set_label('X+Y') plt.show()
class HoughDemo(ImageProcessDemo): TITLE = u"Hough Demo" DEFAULT_IMAGE = "stuff.jpg" SETTINGS = ["th2", "show_canny", "rho", "theta", "hough_th", "minlen", "maxgap", "dp", "mindist", "param2", "min_radius", "max_radius", "blur_sigma", "linewidth", "alpha", "check_line", "check_circle"] check_line = Bool(True) check_circle = Bool(True) #Gaussian blur parameters blur_sigma = Range(0.1, 5.0, 2.0) show_blur = Bool(False) # Canny parameters th2 = Range(0.0, 255.0, 200.0) show_canny = Bool(False) # HoughLine parameters rho = Range(1.0, 10.0, 1.0) theta = Range(0.1, 5.0, 1.0) hough_th = Range(1, 100, 40) minlen = Range(0, 100, 10) maxgap = Range(0, 20, 10) # HoughtCircle parameters dp = Range(1.0, 5.0, 1.9) mindist = Range(1.0, 100.0, 50.0) param2 = Range(5, 100, 50) min_radius = Range(5, 100, 20) max_radius = Range(10, 100, 70) # draw parameters linewidth = Range(1.0, 3.0, 1.0) alpha = Range(0.0, 1.0, 0.6) def control_panel(self): return VGroup( Group( Item("blur_sigma", label=u"标准方差"), Item("show_blur", label=u"显示结果"), label=u"高斯模糊参数" ), Group( Item("th2", label=u"阈值2"), Item("show_canny", label=u"显示结果"), label=u"边缘检测参数" ), Group( Item("rho", label=u"偏移分辨率(像素)"), Item("theta", label=u"角度分辨率(角度)"), Item("hough_th", label=u"阈值"), Item("minlen", label=u"最小长度"), Item("maxgap", label=u"最大空隙"), label=u"直线检测" ), Group( Item("dp", label=u"分辨率(像素)"), Item("mindist", label=u"圆心最小距离(像素)"), Item("param2", label=u"圆心检查阈值"), Item("min_radius", label=u"最小半径"), Item("max_radius", label=u"最大半径"), label=u"圆检测" ), Group( Item("linewidth", label=u"线宽"), Item("alpha", label=u"alpha"), HGroup( Item("check_line", label=u"直线"), Item("check_circle", label=u"圆"), ), label=u"绘图参数" ) ) def __init__(self, **kwargs): super(HoughDemo, self).__init__(**kwargs) self.connect_dirty("th2, show_canny, show_blur, rho, theta, hough_th," "min_radius, max_radius, blur_sigma," "minlen, maxgap, dp, mindist, param2, " "linewidth, alpha, check_line, check_circle") self.lines = LineCollection([], linewidths=2, alpha=0.6) self.axe.add_collection(self.lines) self.circles = EllipseCollection( [], [], [], units="xy", facecolors="none", edgecolors="red", linewidths=2, alpha=0.6, transOffset=self.axe.transData) self.axe.add_collection(self.circles) def _img_changed(self): self.img_gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY) def draw(self): img_smooth = cv2.GaussianBlur(self.img_gray, (0, 0), self.blur_sigma, self.blur_sigma) img_edge = cv2.Canny(img_smooth, self.th2 * 0.5, self.th2) if self.show_blur and self.show_canny: show_img = cv2.cvtColor(np.maximum(img_smooth, img_edge), cv2.COLOR_BAYER_BG2BGR) elif self.show_blur: show_img = cv2.cvtColor(img_smooth, cv2.COLOR_BAYER_BG2BGR) elif self.show_canny: show_img = cv2.cvtColor(img_edge, cv2.COLOR_GRAY2BGR) else: show_img = self.img if self.check_line: theta = self.theta / 180.0 * np.pi lines = cv2.HoughLinesP(img_edge, self.rho, theta, self.hough_th, minLineLength=self.minlen, maxLineGap=self.maxgap) if lines is not None: lines = lines[0] lines.shape = -1, 2, 2 self.lines.set_segments(lines) self.lines.set_visible(True) else: self.lines.set_visible(False) else: self.lines.set_visible(False) if self.check_circle: circles = cv2.HoughCircles(img_smooth, 3, self.dp, self.mindist, param1=self.th2, param2=self.param2, minRadius=self.min_radius, maxRadius=self.max_radius) if circles is not None: circles = circles[0] self.circles._heights = self.circles._widths = circles[:, 2] self.circles.set_offsets(circles[:, :2]) self.circles._angles = np.zeros(len(circles)) self.circles._transOffset = self.axe.transData self.circles.set_visible(True) else: self.circles.set_visible(False) else: self.circles.set_visible(False) self.lines.set_linewidths(self.linewidth) self.circles.set_linewidths(self.linewidth) self.lines.set_alpha(self.alpha) self.circles.set_alpha(self.alpha) self.draw_image(show_img)
from matplotlib.collections import EllipseCollection x = np.arange(10) y = np.arange(15) X, Y = np.meshgrid(x, y) XY = np.column_stack((X.ravel(), Y.ravel())) ww = X / 10.0 hh = Y / 15.0 aa = X * 9 fig, ax = plt.subplots() ec = EllipseCollection(ww, hh, aa, units='x', offsets=XY, transOffset=ax.transData) ec.set_array((X + Y).ravel()) ax.add_collection(ec) ax.autoscale_view() ax.set_xlabel('X') ax.set_ylabel('y') cbar = plt.colorbar(ec) cbar.set_label('X+Y') plt.show() ############################################################################# # # ------------ # # References # """"""""""
x = samples[:,1] y = samples[:,2] fig, ax = plt.subplots() ax.set_xlim(-0.5 * 15, 0.5 * 15) ax.set_ylim(-0.5 * 15, 0.5 * 15) ax.set_aspect('equal') plt.ylabel('position~$y$') plt.xlabel('position~$x$') radius = 1.0 ellipse_pos = EllipseCollection(widths=radius, heights=radius, angles=0, units='xy', facecolors='r', offsets=[], transOffset=ax.transData) ellipse_neg = EllipseCollection(widths=radius, heights=radius, angles=0, units='xy', facecolors='b', offsets=[], transOffset=ax.transData) ax.add_collection(ellipse_pos) ax.add_collection(ellipse_neg) idx_pos = q > 0.0 idx_neg = np.logical_not(idx_pos) ellipse_pos.set_offsets(np.column_stack((x[idx_pos], y[idx_pos]))) ellipse_neg.set_offsets(np.column_stack((x[idx_neg], y[idx_neg]))) #plt.scatter(x, y, s = area, c = ["r","b"]) plt.savefig('../figures/Kristall.pdf', bbox_inches='tight')